dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441
 442 #include <dali-toolkit/devel-api/builder/builder.h>
 443
 444 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 445 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 446
 447 #include <dali-toolkit/devel-api/controls/control-devel.h>
 448 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 449 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 454 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 455
 456 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 457 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 458 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 459
 460 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 463
 464 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 467
 468 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 469
 470 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 471 #include <dali/devel-api/adaptor-framework/image-loading.h>
 472
 473 #include <dali/public-api/events/mouse-button.h>
 474
 475 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 476 #include "web-view-signal-converter.h"
 477
 478
 479 // add here SWIG version check
 480
 481 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 482 // disable Swig-dependent warnings
 483
 484 // 'identifier1' has C-linkage specified,
 485 // but returns UDT 'identifier2' which is incompatible with C
 486 #pragma warning(disable: 4190)
 487
 488 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 489 #pragma warning(disable: 4800)
 490
 491 // debug info too long etc etc
 492 #pragma warning(disable: 4786)
 493 #endif
 494
 495
 496 #include <stdexcept>
 497
 498
 499 #include <string>
 500
 501
 502 #include <vector>
 503 #include <algorithm>
 504 #include <stdexcept>
 505
 506
 507 #include <map>
 508 #include <algorithm>
 509 #include <stdexcept>
 510
 511
 512 #include <utility>
 513
 514
 515 typedef float floatp;
 516
 517 SWIGINTERN floatp *new_floatp(){
 518   return new float();
 519 }
 520 SWIGINTERN void delete_floatp(floatp *self){
 521   if (self) delete self;
 522 }
 523 SWIGINTERN void floatp_assign(floatp *self,float value){
 524   *self = value;
 525 }
 526 SWIGINTERN float floatp_value(floatp *self){
 527   return *self;
 528 }
 529 SWIGINTERN float *floatp_cast(floatp *self){
 530   return self;
 531 }
 532 SWIGINTERN floatp *floatp_frompointer(float *t){
 533   return (floatp *) t;
 534 }
 535
 536 typedef int intp;
 537
 538 SWIGINTERN intp *new_intp(){
 539   return new int();
 540 }
 541 SWIGINTERN void delete_intp(intp *self){
 542   if (self) delete self;
 543 }
 544 SWIGINTERN void intp_assign(intp *self,int value){
 545   *self = value;
 546 }
 547 SWIGINTERN int intp_value(intp *self){
 548   return *self;
 549 }
 550 SWIGINTERN int *intp_cast(intp *self){
 551   return self;
 552 }
 553 SWIGINTERN intp *intp_frompointer(int *t){
 554   return (intp *) t;
 555 }
 556
 557 typedef double doublep;
 558
 559 SWIGINTERN doublep *new_doublep(){
 560   return new double();
 561 }
 562 SWIGINTERN void delete_doublep(doublep *self){
 563   if (self) delete self;
 564 }
 565 SWIGINTERN void doublep_assign(doublep *self,double value){
 566   *self = value;
 567 }
 568 SWIGINTERN double doublep_value(doublep *self){
 569   return *self;
 570 }
 571 SWIGINTERN double *doublep_cast(doublep *self){
 572   return self;
 573 }
 574 SWIGINTERN doublep *doublep_frompointer(double *t){
 575   return (doublep *) t;
 576 }
 577
 578 typedef unsigned int uintp;
 579
 580 SWIGINTERN uintp *new_uintp(){
 581   return new unsigned int();
 582 }
 583 SWIGINTERN void delete_uintp(uintp *self){
 584   if (self) delete self;
 585 }
 586 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 587   *self = value;
 588 }
 589 SWIGINTERN unsigned int uintp_value(uintp *self){
 590   return *self;
 591 }
 592 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 593   return self;
 594 }
 595 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 596   return (uintp *) t;
 597 }
 598
 599 typedef unsigned short ushortp;
 600
 601 SWIGINTERN ushortp *new_ushortp(){
 602   return new unsigned short();
 603 }
 604 SWIGINTERN void delete_ushortp(ushortp *self){
 605   if (self) delete self;
 606 }
 607 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 608   *self = value;
 609 }
 610 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 611   return *self;
 612 }
 613 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 614   return self;
 615 }
 616 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 617   return (ushortp *) t;
 618 }
 619
 620 unsigned int int_to_uint(int x) {
 621    return (unsigned int) x;
 622 }
 623
 624
 625 using namespace Dali;
 626 using namespace Dali::Toolkit;
 627
 628 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 629 {
 630   bool result = false;
 631   try
 632   {
 633     // C++ code. DALi uses Handle <-> Body design pattern.
 634     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 635     // Handles in DALi can be converted into a boolean type
 636     // to check if the handle has a valid body attached to it.
 637     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 638     if( *self )
 639     {
 640       result = true;
 641     }
 642     else
 643     {
 644       result = false;
 645     }
 646   }
 647   catch (std::out_of_range& e)
 648   {
 649     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 650     return 0;
 651   }
 652   catch (std::exception& e)
 653   {
 654     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 655     return 0;
 656   }
 657   catch (DaliException e)
 658   {
 659     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 660     return 0;
 661   }
 662   catch (...)
 663   {
 664     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 665     return 0;
 666   }
 667   return result;
 668 }
 669
 670 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 671 {
 672   bool result = false;
 673   try
 674   {
 675     // C++ code. Check if two handles reference the same implemtion
 676     if( *self == rhs)
 677     {
 678       result = true;
 679     }
 680     else
 681     {
 682       result = false;
 683     }
 684   }
 685   catch (std::out_of_range& e)
 686   {
 687     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 688     return 0;
 689   }
 690   catch (std::exception& e)
 691   {
 692     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 693     return 0;
 694   }
 695   catch (DaliException e)
 696   {
 697     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 698     return 0;
 699   }
 700   catch (...)
 701   {
 702     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 703     return 0;
 704   }
 705   return result;
 706 }
 707
 708
 709 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 710      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 711    }
 712 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 713      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 714    }
 715 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 716         std::vector< Dali::TouchPoint >* pv = 0;
 717         if (capacity >= 0) {
 718           pv = new std::vector< Dali::TouchPoint >();
 719           pv->reserve(capacity);
 720        } else {
 721           throw std::out_of_range("capacity");
 722        }
 723        return pv;
 724       }
 725 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 726         if (index>=0 && index<(int)self->size())
 727           return (*self)[index];
 728         else
 729           throw std::out_of_range("index");
 730       }
 731 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 732         if (index>=0 && index<(int)self->size())
 733           return (*self)[index];
 734         else
 735           throw std::out_of_range("index");
 736       }
 737 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 738         if (index>=0 && index<(int)self->size())
 739           (*self)[index] = val;
 740         else
 741           throw std::out_of_range("index");
 742       }
 743 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 744         self->insert(self->end(), values.begin(), values.end());
 745       }
 746 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 747         if (index < 0)
 748           throw std::out_of_range("index");
 749         if (count < 0)
 750           throw std::out_of_range("count");
 751         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 752           throw std::invalid_argument("invalid range");
 753         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 754       }
 755 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 756         if (index>=0 && index<(int)self->size()+1)
 757           self->insert(self->begin()+index, x);
 758         else
 759           throw std::out_of_range("index");
 760       }
 761 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 762         if (index>=0 && index<(int)self->size()+1)
 763           self->insert(self->begin()+index, values.begin(), values.end());
 764         else
 765           throw std::out_of_range("index");
 766       }
 767 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 768         if (index>=0 && index<(int)self->size())
 769           self->erase(self->begin() + index);
 770         else
 771           throw std::out_of_range("index");
 772       }
 773 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 774         if (index < 0)
 775           throw std::out_of_range("index");
 776         if (count < 0)
 777           throw std::out_of_range("count");
 778         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 779           throw std::invalid_argument("invalid range");
 780         self->erase(self->begin()+index, self->begin()+index+count);
 781       }
 782 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 783         if (count < 0)
 784           throw std::out_of_range("count");
 785         return new std::vector< Dali::TouchPoint >(count, value);
 786       }
 787 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 788         std::reverse(self->begin(), self->end());
 789       }
 790 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 791         if (index < 0)
 792           throw std::out_of_range("index");
 793         if (count < 0)
 794           throw std::out_of_range("count");
 795         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 796           throw std::invalid_argument("invalid range");
 797         std::reverse(self->begin()+index, self->begin()+index+count);
 798       }
 799 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 800         if (index < 0)
 801           throw std::out_of_range("index");
 802         if (index+values.size() > self->size())
 803           throw std::out_of_range("index");
 804         std::copy(values.begin(), values.end(), self->begin()+index);
 805       }
 806 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 807          return self->Empty();
 808       }
 809 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 810         return self->GetConnectionCount();
 811       }
 812 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 813           self->Connect( func );
 814       }
 815 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 816           self->Disconnect( func );
 817       }
 818 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 819           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 820 /*@SWIG@*/ self->Emit( arg );
 821       }
 822 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 823          return self->Empty();
 824       }
 825 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 826         return self->GetConnectionCount();
 827       }
 828 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 829           self->Connect( func );
 830       }
 831 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 832           self->Disconnect( func );
 833       }
 834 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 835           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 836 /*@SWIG@*/ self->Emit( arg );
 837       }
 838 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 839          return self->Empty();
 840       }
 841 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 842         return self->GetConnectionCount();
 843       }
 844 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 845           self->Connect( func );
 846       }
 847 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 848           self->Disconnect( func );
 849       }
 850 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 851           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 852 /*@SWIG@*/ self->Emit( arg );
 853       }
 854 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 855          return self->Empty();
 856       }
 857 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 858         return self->GetConnectionCount();
 859       }
 860 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 861           self->Connect( func );
 862       }
 863 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 864           self->Disconnect( func );
 865       }
 866 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 867           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 868 /*@SWIG@*/ self->Emit( arg );
 869       }
 870 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 871          return self->Empty();
 872       }
 873 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 874         return self->GetConnectionCount();
 875       }
 876 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 877           self->Connect( func );
 878       }
 879 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 880           self->Disconnect( func );
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 883           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 884 /*@SWIG@*/ self->Emit( arg );
 885       }
 886 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 887          return self->Empty();
 888       }
 889 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 890         return self->GetConnectionCount();
 891       }
 892 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 893         self->Connect( func );
 894       }
 895 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 896         self->Disconnect( func );
 897       }
 898 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 899         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 900 /*@SWIG@*/ self->Emit( arg1, arg2 );
 901       }
 902 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 903          return self->Empty();
 904       }
 905 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 906         return self->GetConnectionCount();
 907       }
 908 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 909         self->Connect( func );
 910       }
 911 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 912         self->Disconnect( func );
 913       }
 914 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 915         return self->Emit( arg1, arg2 );
 916       }
 917 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 918          return self->Empty();
 919       }
 920 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 921         return self->GetConnectionCount();
 922       }
 923 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 924         self->Connect( func );
 925       }
 926 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 927         self->Disconnect( func );
 928       }
 929 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 930         return self->Emit( arg1, arg2 );
 931       }
 932 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 933          return self->Empty();
 934       }
 935 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 936         return self->GetConnectionCount();
 937       }
 938 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 939         self->Connect( func );
 940       }
 941 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 942         self->Disconnect( func );
 943       }
 944 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 945         return self->Emit( arg1, arg2 );
 946       }
 947 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 948          return self->Empty();
 949       }
 950 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 951         return self->GetConnectionCount();
 952       }
 953 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 954           self->Connect( func );
 955       }
 956 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 957           self->Disconnect( func );
 958       }
 959 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 960           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 961 /*@SWIG@*/ self->Emit( arg );
 962       }
 963 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 964          return self->Empty();
 965       }
 966 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 967         return self->GetConnectionCount();
 968       }
 969 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 970           self->Connect( func );
 971       }
 972 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 973           self->Disconnect( func );
 974       }
 975 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 976           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 977 /*@SWIG@*/ self->Emit( arg );
 978       }
 979 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 980          return self->Empty();
 981       }
 982 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 983         return self->GetConnectionCount();
 984       }
 985 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 986           self->Connect( func );
 987       }
 988 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 989           self->Disconnect( func );
 990       }
 991 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 992           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 993 /*@SWIG@*/ self->Emit( arg );
 994       }
 995 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 996          return self->Empty();
 997       }
 998 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 999         return self->GetConnectionCount();
1000       }
1001 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1002           self->Connect( func );
1003       }
1004 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1005           self->Disconnect( func );
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1008           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1009 /*@SWIG@*/ self->Emit( arg );
1010       }
1011 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1012          return self->Empty();
1013       }
1014 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1015         return self->GetConnectionCount();
1016       }
1017 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1018         self->Connect( func );
1019       }
1020 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1021         self->Disconnect( func );
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1024         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1025 /*@SWIG@*/ self->Emit( arg1, arg2 );
1026       }
1027 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1028          return self->Empty();
1029       }
1030 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1031         return self->GetConnectionCount();
1032       }
1033 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1034         self->Connect( func );
1035       }
1036 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1037         self->Disconnect( func );
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1040         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1041 /*@SWIG@*/ self->Emit( arg1, arg2 );
1042       }
1043 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1044          return self->Empty();
1045       }
1046 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1047         return self->GetConnectionCount();
1048       }
1049 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1050         self->Connect( func );
1051       }
1052 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1053         self->Disconnect( func );
1054       }
1055 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1056         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1057 /*@SWIG@*/ self->Emit( arg1, arg2 );
1058       }
1059 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1060          return self->Empty();
1061       }
1062 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1063         return self->GetConnectionCount();
1064       }
1065 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1066           self->Connect( func );
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1069           self->Disconnect( func );
1070       }
1071 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1072           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1073 /*@SWIG@*/ self->Emit( arg );
1074       }
1075 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1076          return self->Empty();
1077       }
1078 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1079         return self->GetConnectionCount();
1080       }
1081 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1082           return self->Connect( func );
1083       }
1084 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1085           self->Disconnect( func );
1086       }
1087 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1088           self->Emit( arg1, arg3 );
1089       }
1090 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1091          return self->Empty();
1092       }
1093 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1094         return self->GetConnectionCount();
1095       }
1096 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1097           return self->Connect( func );
1098       }
1099 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1100           self->Disconnect( func );
1101       }
1102 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1103           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1104 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1105       }
1106
1107 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1108          return self->Empty();
1109       }
1110 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1111         return self->GetConnectionCount();
1112       }
1113 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1114           self->Connect( func );
1115       }
1116 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1117           self->Disconnect( func );
1118       }
1119 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1120           return self->Emit();
1121       }
1122
1123 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1124         std::vector< unsigned int >* pv = 0;
1125         if (capacity >= 0) {
1126           pv = new std::vector< unsigned int >();
1127           pv->reserve(capacity);
1128        } else {
1129           throw std::out_of_range("capacity");
1130        }
1131        return pv;
1132       }
1133 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1134         if (index>=0 && index<(int)self->size())
1135           return (*self)[index];
1136         else
1137           throw std::out_of_range("index");
1138       }
1139 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1140         if (index>=0 && index<(int)self->size())
1141           return (*self)[index];
1142         else
1143           throw std::out_of_range("index");
1144       }
1145 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1146         if (index>=0 && index<(int)self->size())
1147           (*self)[index] = val;
1148         else
1149           throw std::out_of_range("index");
1150       }
1151 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1152         self->insert(self->end(), values.begin(), values.end());
1153       }
1154 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1155         if (index < 0)
1156           throw std::out_of_range("index");
1157         if (count < 0)
1158           throw std::out_of_range("count");
1159         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1160           throw std::invalid_argument("invalid range");
1161         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1162       }
1163 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1164         if (index>=0 && index<(int)self->size()+1)
1165           self->insert(self->begin()+index, x);
1166         else
1167           throw std::out_of_range("index");
1168       }
1169 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1170         if (index>=0 && index<(int)self->size()+1)
1171           self->insert(self->begin()+index, values.begin(), values.end());
1172         else
1173           throw std::out_of_range("index");
1174       }
1175 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1176         if (index>=0 && index<(int)self->size())
1177           self->erase(self->begin() + index);
1178         else
1179           throw std::out_of_range("index");
1180       }
1181 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1182         if (index < 0)
1183           throw std::out_of_range("index");
1184         if (count < 0)
1185           throw std::out_of_range("count");
1186         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1187           throw std::invalid_argument("invalid range");
1188         self->erase(self->begin()+index, self->begin()+index+count);
1189       }
1190 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1191         if (count < 0)
1192           throw std::out_of_range("count");
1193         return new std::vector< unsigned int >(count, value);
1194       }
1195 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1196         std::reverse(self->begin(), self->end());
1197       }
1198 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1199         if (index < 0)
1200           throw std::out_of_range("index");
1201         if (count < 0)
1202           throw std::out_of_range("count");
1203         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1204           throw std::invalid_argument("invalid range");
1205         std::reverse(self->begin()+index, self->begin()+index+count);
1206       }
1207 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1208         if (index < 0)
1209           throw std::out_of_range("index");
1210         if (index+values.size() > self->size())
1211           throw std::out_of_range("index");
1212         std::copy(values.begin(), values.end(), self->begin()+index);
1213       }
1214 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1215         return std::find(self->begin(), self->end(), value) != self->end();
1216       }
1217 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1218         int index = -1;
1219         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1220         if (it != self->end())
1221           index = (int)(it - self->begin());
1222         return index;
1223       }
1224 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1225         int index = -1;
1226         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1227         if (rit != self->rend())
1228           index = (int)(self->rend() - 1 - rit);
1229         return index;
1230       }
1231 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1232         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1233         if (it != self->end()) {
1234           self->erase(it);
1235           return true;
1236         }
1237         return false;
1238       }
1239 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1240         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1241         if (capacity >= 0) {
1242           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1243           pv->reserve(capacity);
1244        } else {
1245           throw std::out_of_range("capacity");
1246        }
1247        return pv;
1248       }
1249 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1250         if (index>=0 && index<(int)self->size())
1251           return (*self)[index];
1252         else
1253           throw std::out_of_range("index");
1254       }
1255 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1256         if (index>=0 && index<(int)self->size())
1257           return (*self)[index];
1258         else
1259           throw std::out_of_range("index");
1260       }
1261 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1262         if (index>=0 && index<(int)self->size())
1263           (*self)[index] = val;
1264         else
1265           throw std::out_of_range("index");
1266       }
1267 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1268         self->insert(self->end(), values.begin(), values.end());
1269       }
1270 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1271         if (index < 0)
1272           throw std::out_of_range("index");
1273         if (count < 0)
1274           throw std::out_of_range("count");
1275         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1276           throw std::invalid_argument("invalid range");
1277         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1278       }
1279 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1280         if (index>=0 && index<(int)self->size()+1)
1281           self->insert(self->begin()+index, x);
1282         else
1283           throw std::out_of_range("index");
1284       }
1285 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1286         if (index>=0 && index<(int)self->size()+1)
1287           self->insert(self->begin()+index, values.begin(), values.end());
1288         else
1289           throw std::out_of_range("index");
1290       }
1291 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1292         if (index>=0 && index<(int)self->size())
1293           self->erase(self->begin() + index);
1294         else
1295           throw std::out_of_range("index");
1296       }
1297 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1298         if (index < 0)
1299           throw std::out_of_range("index");
1300         if (count < 0)
1301           throw std::out_of_range("count");
1302         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1303           throw std::invalid_argument("invalid range");
1304         self->erase(self->begin()+index, self->begin()+index+count);
1305       }
1306 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1307         if (count < 0)
1308           throw std::out_of_range("count");
1309         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1310       }
1311 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1312         std::reverse(self->begin(), self->end());
1313       }
1314 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1315         if (index < 0)
1316           throw std::out_of_range("index");
1317         if (count < 0)
1318           throw std::out_of_range("count");
1319         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1320           throw std::invalid_argument("invalid range");
1321         std::reverse(self->begin()+index, self->begin()+index+count);
1322       }
1323 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1324         if (index < 0)
1325           throw std::out_of_range("index");
1326         if (index+values.size() > self->size())
1327           throw std::out_of_range("index");
1328         std::copy(values.begin(), values.end(), self->begin()+index);
1329       }
1330 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1331         std::vector< Dali::Actor >* pv = 0;
1332         if (capacity >= 0) {
1333           pv = new std::vector< Dali::Actor >();
1334           pv->reserve(capacity);
1335        } else {
1336           throw std::out_of_range("capacity");
1337        }
1338        return pv;
1339       }
1340 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1341         if (index>=0 && index<(int)self->size())
1342           return (*self)[index];
1343         else
1344           throw std::out_of_range("index");
1345       }
1346 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1347         if (index>=0 && index<(int)self->size())
1348           return (*self)[index];
1349         else
1350           throw std::out_of_range("index");
1351       }
1352 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1353         if (index>=0 && index<(int)self->size())
1354           (*self)[index] = val;
1355         else
1356           throw std::out_of_range("index");
1357       }
1358 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1359         self->insert(self->end(), values.begin(), values.end());
1360       }
1361 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1362         if (index < 0)
1363           throw std::out_of_range("index");
1364         if (count < 0)
1365           throw std::out_of_range("count");
1366         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1367           throw std::invalid_argument("invalid range");
1368         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1369       }
1370 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1371         if (index>=0 && index<(int)self->size()+1)
1372           self->insert(self->begin()+index, x);
1373         else
1374           throw std::out_of_range("index");
1375       }
1376 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1377         if (index>=0 && index<(int)self->size()+1)
1378           self->insert(self->begin()+index, values.begin(), values.end());
1379         else
1380           throw std::out_of_range("index");
1381       }
1382 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1383         if (index>=0 && index<(int)self->size())
1384           self->erase(self->begin() + index);
1385         else
1386           throw std::out_of_range("index");
1387       }
1388 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1389         if (index < 0)
1390           throw std::out_of_range("index");
1391         if (count < 0)
1392           throw std::out_of_range("count");
1393         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1394           throw std::invalid_argument("invalid range");
1395         self->erase(self->begin()+index, self->begin()+index+count);
1396       }
1397 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1398         if (count < 0)
1399           throw std::out_of_range("count");
1400         return new std::vector< Dali::Actor >(count, value);
1401       }
1402 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1403         std::reverse(self->begin(), self->end());
1404       }
1405 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1406         if (index < 0)
1407           throw std::out_of_range("index");
1408         if (count < 0)
1409           throw std::out_of_range("count");
1410         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1411           throw std::invalid_argument("invalid range");
1412         std::reverse(self->begin()+index, self->begin()+index+count);
1413       }
1414 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1415         if (index < 0)
1416           throw std::out_of_range("index");
1417         if (index+values.size() > self->size())
1418           throw std::out_of_range("index");
1419         std::copy(values.begin(), values.end(), self->begin()+index);
1420       }
1421 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1422          return self->Empty();
1423       }
1424 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1425         return self->GetConnectionCount();
1426       }
1427 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1428           self->Connect( func );
1429       }
1430 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1431           self->Disconnect( func );
1432       }
1433 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1434           return self->Emit( arg );
1435       }
1436 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1437          return self->Empty();
1438       }
1439 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1440         return self->GetConnectionCount();
1441       }
1442 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1443         self->Connect( func );
1444       }
1445 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1446         self->Disconnect( func );
1447       }
1448 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1449         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1450 /*@SWIG@*/ self->Emit( arg1, arg2 );
1451       }
1452 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1453          return self->Empty();
1454       }
1455 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1456         return self->GetConnectionCount();
1457       }
1458 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1459         self->Connect( func );
1460       }
1461 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1462         self->Disconnect( func );
1463       }
1464 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1465         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1466 /*@SWIG@*/ self->Emit( arg1, arg2 );
1467       }
1468 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1469          return self->Empty();
1470       }
1471 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1472         return self->GetConnectionCount();
1473       }
1474 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1475         self->Connect( func );
1476       }
1477 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1478         self->Disconnect( func );
1479       }
1480 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1481         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1482 /*@SWIG@*/ self->Emit( arg1, arg2 );
1483       }
1484 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1485          return self->Empty();
1486       }
1487 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1488         return self->GetConnectionCount();
1489       }
1490 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1491         self->Connect( func );
1492       }
1493 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1494         self->Disconnect( func );
1495       }
1496 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1497         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1498 /*@SWIG@*/ self->Emit( arg1, arg2 );
1499       }
1500 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1501          return self->Empty();
1502       }
1503 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1504         return self->GetConnectionCount();
1505       }
1506 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1507           self->Connect( func );
1508       }
1509 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1510           self->Disconnect( func );
1511       }
1512 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1513           return self->Emit( arg );
1514       }
1515 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1516          return self->Empty();
1517       }
1518 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1519         return self->GetConnectionCount();
1520       }
1521 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1522           self->Connect( func );
1523       }
1524 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1525           self->Disconnect( func );
1526       }
1527 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1528           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1529 /*@SWIG@*/ self->Emit( arg );
1530       }
1531 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1532          return self->Empty();
1533       }
1534 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1535         return self->GetConnectionCount();
1536       }
1537 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1538           return self->Connect( func );
1539       }
1540 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1541           self->Disconnect( func );
1542       }
1543 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1544           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1545 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1546       }
1547 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1548          return self->Empty();
1549       }
1550 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1551         return self->GetConnectionCount();
1552       }
1553 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1554           self->Connect( func );
1555       }
1556 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1557           self->Disconnect( func );
1558       }
1559 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1560           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1561 /*@SWIG@*/ self->Emit( arg );
1562       }
1563 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1564          return self->Empty();
1565       }
1566 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1567         return self->GetConnectionCount();
1568       }
1569 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1570           return self->Connect( func );
1571       }
1572 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1573           self->Disconnect( func );
1574       }
1575 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1576           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1577 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1578       }
1579 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1580          return self->Empty();
1581       }
1582 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1583         return self->GetConnectionCount();
1584       }
1585 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1586           self->Connect( func );
1587       }
1588 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1589           self->Disconnect( func );
1590       }
1591 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1592           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1593 /*@SWIG@*/ self->Emit( arg );
1594       }
1595 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1596          return self->Empty();
1597       }
1598 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1599         return self->GetConnectionCount();
1600       }
1601 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1602           self->Connect( func );
1603       }
1604 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1605           self->Disconnect( func );
1606       }
1607 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1608           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1609 /*@SWIG@*/ self->Emit( arg );
1610       }
1611
1612
1613 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1614          return self->Empty();
1615       }
1616 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1617         return self->GetConnectionCount();
1618       }
1619 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1620         self->Connect( func );
1621       }
1622 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1623         self->Disconnect( func );
1624       }
1625 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1626         return self->Emit( arg1, arg2 );
1627       }
1628 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1629          return self->Empty();
1630       }
1631 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1632         return self->GetConnectionCount();
1633       }
1634 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1635           self->Connect( func );
1636       }
1637 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1638           self->Disconnect( func );
1639       }
1640 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1641           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1642 /*@SWIG@*/ self->Emit( arg );
1643       }
1644 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1645          return self->Empty();
1646       }
1647 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1648         return self->GetConnectionCount();
1649       }
1650 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1651           self->Connect( func );
1652       }
1653 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1654           self->Disconnect( func );
1655       }
1656 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1657           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1658 /*@SWIG@*/ self->Emit( arg );
1659       }
1660 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1661          return self->Empty();
1662       }
1663 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1664         return self->GetConnectionCount();
1665       }
1666 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1667         self->Connect( func );
1668       }
1669 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1670         self->Disconnect( func );
1671       }
1672 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1673         return self->Emit( arg1, arg2 );
1674       }
1675 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1676          return self->Empty();
1677       }
1678 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1679         return self->GetConnectionCount();
1680       }
1681 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1682         self->Connect( func );
1683       }
1684 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1685         self->Disconnect( func );
1686       }
1687 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1688         return self->Emit( arg1, arg2 );
1689       }
1690
1691 /* ---------------------------------------------------
1692  * C++ director class methods
1693  * --------------------------------------------------- */
1694
1695 #include "dali_wrap.h"
1696
1697 /*
1698  *  Widget director
1699  */
1700 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1701   swig_init_callbacks();
1702 }
1703
1704 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1705 }
1706
1707 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1708   char * jcontentInfo = 0 ;
1709   void * jwindow  ;
1710
1711   if (!swig_callbackOnCreate) {
1712     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1713     return;
1714   } else {
1715     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1716     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1717     swig_callbackOnCreate(jcontentInfo, jwindow);
1718   }
1719 }
1720
1721 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1722   char * jcontentInfo = 0 ;
1723   int jtype  ;
1724
1725   if (!swig_callbackOnTerminate) {
1726     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1727     return;
1728   } else {
1729     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1730     jtype = (int)type;
1731     swig_callbackOnTerminate(jcontentInfo, jtype);
1732   }
1733 }
1734
1735 void SwigDirector_WidgetImpl::OnPause() {
1736   if (!swig_callbackOnPause) {
1737     Dali::Internal::Adaptor::Widget::OnPause();
1738     return;
1739   } else {
1740     swig_callbackOnPause();
1741   }
1742 }
1743
1744 void SwigDirector_WidgetImpl::OnResume() {
1745   if (!swig_callbackOnResume) {
1746     Dali::Internal::Adaptor::Widget::OnResume();
1747     return;
1748   } else {
1749     swig_callbackOnResume();
1750   }
1751 }
1752
1753 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1754   void * jwindow  ;
1755
1756   if (!swig_callbackOnResize) {
1757     Dali::Internal::Adaptor::Widget::OnResize(window);
1758     return;
1759   } else {
1760     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1761     swig_callbackOnResize(jwindow);
1762   }
1763 }
1764
1765 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1766   char * jcontentInfo = 0 ;
1767   int jforce  ;
1768
1769   if (!swig_callbackOnUpdate) {
1770     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1771     return;
1772   } else {
1773     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1774     jforce = force;
1775     swig_callbackOnUpdate(jcontentInfo, jforce);
1776   }
1777 }
1778
1779 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1780   void * jslotObserver = 0 ;
1781   void * jcallback = 0 ;
1782
1783   if (!swig_callbackSignalConnected) {
1784     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1785     return;
1786   } else {
1787     jslotObserver = (void *) slotObserver;
1788     jcallback = (void *) callback;
1789     swig_callbackSignalConnected(jslotObserver, jcallback);
1790   }
1791 }
1792
1793 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1794   void * jslotObserver = 0 ;
1795   void * jcallback = 0 ;
1796
1797   if (!swig_callbackSignalDisconnected) {
1798     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1799     return;
1800   } else {
1801     jslotObserver = (void *) slotObserver;
1802     jcallback = (void *) callback;
1803     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1804   }
1805 }
1806
1807 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1808
1809   swig_callbackOnCreate = callbackOnCreate;
1810   swig_callbackOnTerminate = callbackOnTerminate;
1811   swig_callbackOnPause = callbackOnPause;
1812   swig_callbackOnResume = callbackOnResume;
1813   swig_callbackOnResize = callbackOnResize;
1814   swig_callbackOnUpdate = callbackOnUpdate;
1815   swig_callbackSignalConnected = callbackSignalConnected;
1816   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1817 }
1818
1819 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1820   swig_callbackOnCreate = 0;
1821   swig_callbackOnTerminate = 0;
1822   swig_callbackOnPause = 0;
1823   swig_callbackOnResume = 0;
1824   swig_callbackOnResize = 0;
1825   swig_callbackOnUpdate = 0;
1826   swig_callbackSignalConnected = 0;
1827   swig_callbackSignalDisconnected = 0;
1828 }
1829
1830
1831 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1832   swig_init_callbacks();
1833 }
1834
1835 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1836
1837 }
1838
1839
1840 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1841   int jdepth  ;
1842
1843   if (!swig_callbackOnStageConnection) {
1844     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1845     return;
1846   } else {
1847     jdepth = depth;
1848     swig_callbackOnStageConnection(jdepth);
1849   }
1850 }
1851
1852 void SwigDirector_ViewImpl::OnStageDisconnection() {
1853   if (!swig_callbackOnStageDisconnection) {
1854     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1855     return;
1856   } else {
1857     swig_callbackOnStageDisconnection();
1858   }
1859 }
1860
1861 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1862   void * jchild = 0 ;
1863
1864   if (!swig_callbackOnChildAdd) {
1865     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1866     return;
1867   } else {
1868     jchild = (Dali::Actor *) &child;
1869     swig_callbackOnChildAdd(jchild);
1870   }
1871 }
1872
1873 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1874   void * jchild = 0 ;
1875
1876   if (!swig_callbackOnChildRemove) {
1877     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1878     return;
1879   } else {
1880     jchild = (Dali::Actor *) &child;
1881     swig_callbackOnChildRemove(jchild);
1882   }
1883 }
1884
1885 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1886   int jindex  ;
1887   void * jpropertyValue  ;
1888
1889   if (!swig_callbackOnPropertySet) {
1890     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1891     return;
1892   } else {
1893     jindex = index;
1894     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1895     swig_callbackOnPropertySet(jindex, jpropertyValue);
1896   }
1897 }
1898
1899 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1900   void * jtargetSize = 0 ;
1901
1902   if (!swig_callbackOnSizeSet) {
1903     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1904     return;
1905   } else {
1906     jtargetSize = (Dali::Vector3 *) &targetSize;
1907     swig_callbackOnSizeSet(jtargetSize);
1908   }
1909 }
1910
1911 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1912   void * janimation = 0 ;
1913   void * jtargetSize = 0 ;
1914
1915   if (!swig_callbackOnSizeAnimation) {
1916     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1917     return;
1918   } else {
1919     janimation = (Dali::Animation *) &animation;
1920     jtargetSize = (Dali::Vector3 *) &targetSize;
1921     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1922   }
1923 }
1924
1925 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1926   bool c_result = SwigValueInit< bool >() ;
1927   unsigned int jresult = 0 ;
1928   void * jarg0 = 0 ;
1929
1930   if (!swig_callbackOnTouchEvent) {
1931     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1932   } else {
1933     jarg0 = (Dali::TouchEvent *) &event;
1934     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1935     c_result = jresult ? true : false;
1936   }
1937   return c_result;
1938 }
1939
1940 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1941   bool c_result = SwigValueInit< bool >() ;
1942   unsigned int jresult = 0 ;
1943   void * jarg0 = 0 ;
1944
1945   if (!swig_callbackOnHoverEvent) {
1946     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1947   } else {
1948     jarg0 = (Dali::HoverEvent *) &event;
1949     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1950     c_result = jresult ? true : false;
1951   }
1952   return c_result;
1953 }
1954
1955 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1956   bool c_result = SwigValueInit< bool >() ;
1957   unsigned int jresult = 0 ;
1958   void * jarg0 = 0 ;
1959
1960   if (!swig_callbackOnKeyEvent) {
1961     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1962   } else {
1963     jarg0 = (Dali::KeyEvent *) &event;
1964     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1965     c_result = jresult ? true : false;
1966   }
1967   return c_result;
1968 }
1969
1970 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1971   bool c_result = SwigValueInit< bool >() ;
1972   unsigned int jresult = 0 ;
1973   void * jarg0 = 0 ;
1974
1975   if (!swig_callbackOnWheelEvent) {
1976     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1977   } else {
1978     jarg0 = (Dali::WheelEvent *) &event;
1979     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1980     c_result = jresult ? true : false;
1981   }
1982   return c_result;
1983 }
1984
1985 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1986   void * jsize = 0 ;
1987   void * jcontainer = 0 ;
1988
1989   if (!swig_callbackOnRelayout) {
1990     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1991     return;
1992   } else {
1993     jsize = (Dali::Vector2 *) &size;
1994     jcontainer = (Dali::RelayoutContainer *) &container;
1995     swig_callbackOnRelayout(jsize, jcontainer);
1996   }
1997 }
1998
1999 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2000   int jpolicy  ;
2001   int jdimension  ;
2002
2003   if (!swig_callbackOnSetResizePolicy) {
2004     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2005     return;
2006   } else {
2007     jpolicy = (int)policy;
2008     jdimension = (int)dimension;
2009     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2010   }
2011 }
2012
2013 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2014   Dali::Vector3 c_result ;
2015   void * jresult = 0 ;
2016
2017   if (!swig_callbackGetNaturalSize) {
2018     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2019   } else {
2020     jresult = (void *) swig_callbackGetNaturalSize();
2021     if (!jresult) {
2022       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2023       return c_result;
2024     }
2025     c_result = *(Dali::Vector3 *)jresult;
2026   }
2027   return c_result;
2028 }
2029
2030 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2031   float c_result = SwigValueInit< float >() ;
2032   float jresult = 0 ;
2033   void * jchild = 0 ;
2034   int jdimension  ;
2035
2036   if (!swig_callbackCalculateChildSize) {
2037     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2038   } else {
2039     jchild = (Dali::Actor *) &child;
2040     jdimension = (int)dimension;
2041     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2042     c_result = (float)jresult;
2043   }
2044   return c_result;
2045 }
2046
2047 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2048   float c_result = SwigValueInit< float >() ;
2049   float jresult = 0 ;
2050   float jwidth  ;
2051
2052   if (!swig_callbackGetHeightForWidth) {
2053     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2054   } else {
2055     jwidth = width;
2056     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2057     c_result = (float)jresult;
2058   }
2059   return c_result;
2060 }
2061
2062 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2063   float c_result = SwigValueInit< float >() ;
2064   float jresult = 0 ;
2065   float jheight  ;
2066
2067   if (!swig_callbackGetWidthForHeight) {
2068     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2069   } else {
2070     jheight = height;
2071     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2072     c_result = (float)jresult;
2073   }
2074   return c_result;
2075 }
2076
2077 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2078   bool c_result = SwigValueInit< bool >() ;
2079   unsigned int jresult = 0 ;
2080   int jdimension  ;
2081
2082   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2083     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2084   } else {
2085     jdimension = (int)dimension;
2086     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2087     c_result = jresult ? true : false;
2088   }
2089   return c_result;
2090 }
2091
2092 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2093   int jdimension  ;
2094
2095   if (!swig_callbackOnCalculateRelayoutSize) {
2096     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2097     return;
2098   } else {
2099     jdimension = (int)dimension;
2100     swig_callbackOnCalculateRelayoutSize(jdimension);
2101   }
2102 }
2103
2104 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2105   float jsize  ;
2106   int jdimension  ;
2107
2108   if (!swig_callbackOnLayoutNegotiated) {
2109     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2110     return;
2111   } else {
2112     jsize = size;
2113     jdimension = (int)dimension;
2114     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2115   }
2116 }
2117
2118 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2119   return Dali::CustomActorImpl::GetExtension();
2120 }
2121
2122 void SwigDirector_ViewImpl::OnInitialize() {
2123   if (!swig_callbackOnInitialize) {
2124     Dali::Toolkit::Internal::Control::OnInitialize();
2125     return;
2126   } else {
2127     swig_callbackOnInitialize();
2128   }
2129 }
2130
2131 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2132   void * jchild = 0 ;
2133
2134   if (!swig_callbackOnControlChildAdd) {
2135     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2136     return;
2137   } else {
2138     jchild = (Dali::Actor *) &child;
2139     swig_callbackOnControlChildAdd(jchild);
2140   }
2141 }
2142
2143 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2144   void * jchild = 0 ;
2145
2146   if (!swig_callbackOnControlChildRemove) {
2147     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2148     return;
2149   } else {
2150     jchild = (Dali::Actor *) &child;
2151     swig_callbackOnControlChildRemove(jchild);
2152   }
2153 }
2154
2155 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2156   void * jstyleManager  ;
2157   int jchange  ;
2158
2159   if (!swig_callbackOnStyleChange) {
2160     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2161     return;
2162   } else {
2163     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2164     jchange = (int)change;
2165     swig_callbackOnStyleChange(jstyleManager, jchange);
2166   }
2167 }
2168
2169 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2170   bool c_result = SwigValueInit< bool >() ;
2171   unsigned int jresult = 0 ;
2172
2173   if (!swig_callbackOnAccessibilityActivated) {
2174     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2175   } else {
2176     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2177     c_result = jresult ? true : false;
2178   }
2179   return c_result;
2180 }
2181
2182 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2183   bool c_result = SwigValueInit< bool >() ;
2184   unsigned int jresult = 0 ;
2185   void * jgesture  ;
2186
2187   if (!swig_callbackOnAccessibilityPan) {
2188     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2189   } else {
2190     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2191     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2192     c_result = jresult ? true : false;
2193   }
2194   return c_result;
2195 }
2196
2197 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2198   bool c_result = SwigValueInit< bool >() ;
2199   unsigned int jresult = 0 ;
2200   void * jtouchEvent = 0 ;
2201
2202   if (!swig_callbackOnAccessibilityTouch) {
2203     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2204   } else {
2205     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2206     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2207     c_result = jresult ? true : false;
2208   }
2209   return c_result;
2210 }
2211
2212 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2213   bool c_result = SwigValueInit< bool >() ;
2214   unsigned int jresult = 0 ;
2215   unsigned int jisIncrease  ;
2216
2217   if (!swig_callbackOnAccessibilityValueChange) {
2218     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2219   } else {
2220     jisIncrease = isIncrease;
2221     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2222     c_result = jresult ? true : false;
2223   }
2224   return c_result;
2225 }
2226
2227 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2228   bool c_result = SwigValueInit< bool >() ;
2229   unsigned int jresult = 0 ;
2230
2231   if (!swig_callbackOnAccessibilityZoom) {
2232     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2233   } else {
2234     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2235     c_result = jresult ? true : false;
2236   }
2237   return c_result;
2238 }
2239
2240 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2241   if (!swig_callbackOnKeyInputFocusGained) {
2242     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2243     return;
2244   } else {
2245     swig_callbackOnKeyInputFocusGained();
2246   }
2247 }
2248
2249 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2250   if (!swig_callbackOnKeyInputFocusLost) {
2251     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2252     return;
2253   } else {
2254     swig_callbackOnKeyInputFocusLost();
2255   }
2256 }
2257
2258 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2259   Dali::Actor c_result ;
2260   void * jresult = 0 ;
2261   void * jcurrentFocusedActor  ;
2262   int jdirection  ;
2263   unsigned int jloopEnabled  ;
2264
2265   if (!swig_callbackGetNextKeyboardFocusableActor) {
2266     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2267   } else {
2268     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2269     jdirection = (int)direction;
2270     jloopEnabled = loopEnabled;
2271     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2272     if (!jresult) {
2273       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2274       return c_result;
2275     }
2276     c_result = *(Dali::Actor *)jresult;
2277   }
2278   return c_result;
2279 }
2280
2281 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2282   void * jcommitedFocusableActor  ;
2283
2284   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2285     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2286     return;
2287   } else {
2288     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2289     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2290   }
2291 }
2292
2293 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2294   bool c_result = SwigValueInit< bool >() ;
2295   unsigned int jresult = 0 ;
2296
2297   if (!swig_callbackOnKeyboardEnter) {
2298     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2299   } else {
2300     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2301     c_result = jresult ? true : false;
2302   }
2303   return c_result;
2304 }
2305
2306 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2307   void * jpinch = 0 ;
2308
2309   if (!swig_callbackOnPinch) {
2310     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2311     return;
2312   } else {
2313     jpinch = (Dali::PinchGesture *) &pinch;
2314     swig_callbackOnPinch(jpinch);
2315   }
2316 }
2317
2318 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2319   void * jpan = 0 ;
2320
2321   if (!swig_callbackOnPan) {
2322     Dali::Toolkit::Internal::Control::OnPan(pan);
2323     return;
2324   } else {
2325     jpan = (Dali::PanGesture *) &pan;
2326     swig_callbackOnPan(jpan);
2327   }
2328 }
2329
2330 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2331   void * jtap = 0 ;
2332
2333   if (!swig_callbackOnTap) {
2334     Dali::Toolkit::Internal::Control::OnTap(tap);
2335     return;
2336   } else {
2337     jtap = (Dali::TapGesture *) &tap;
2338     swig_callbackOnTap(jtap);
2339   }
2340 }
2341
2342 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2343   void * jlongPress = 0 ;
2344
2345   if (!swig_callbackOnLongPress) {
2346     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2347     return;
2348   } else {
2349     jlongPress = (Dali::LongPressGesture *) &longPress;
2350     swig_callbackOnLongPress(jlongPress);
2351   }
2352 }
2353
2354 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2355   void * jslotObserver = 0 ;
2356   void * jcallback = 0 ;
2357
2358   if (!swig_callbackSignalConnected) {
2359     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2360     return;
2361   } else {
2362     jslotObserver = (void *) slotObserver;
2363     jcallback = (void *) callback;
2364     swig_callbackSignalConnected(jslotObserver, jcallback);
2365   }
2366 }
2367
2368 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2369   void * jslotObserver = 0 ;
2370   void * jcallback = 0 ;
2371
2372   if (!swig_callbackSignalDisconnected) {
2373     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2374     return;
2375   } else {
2376     jslotObserver = (void *) slotObserver;
2377     jcallback = (void *) callback;
2378     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2379   }
2380 }
2381
2382 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2383   return Dali::Toolkit::Internal::Control::GetControlExtension();
2384 }
2385
2386 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2387   swig_callbackOnStageConnection = callbackOnStageConnection;
2388   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2389   swig_callbackOnChildAdd = callbackOnChildAdd;
2390   swig_callbackOnChildRemove = callbackOnChildRemove;
2391   swig_callbackOnPropertySet = callbackOnPropertySet;
2392   swig_callbackOnSizeSet = callbackOnSizeSet;
2393   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2394   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2395   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2396   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2397   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2398   swig_callbackOnRelayout = callbackOnRelayout;
2399   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2400   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2401   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2402   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2403   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2404   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2405   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2406   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2407   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2408   swig_callbackOnInitialize = callbackOnInitialize;
2409   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2410   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2411   swig_callbackOnStyleChange = callbackOnStyleChange;
2412   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2413   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2414   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2415   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2416   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2417   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2418   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2419   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2420   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2421   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2422   swig_callbackOnPinch = callbackOnPinch;
2423   swig_callbackOnPan = callbackOnPan;
2424   swig_callbackOnTap = callbackOnTap;
2425   swig_callbackOnLongPress = callbackOnLongPress;
2426   swig_callbackSignalConnected = callbackSignalConnected;
2427   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2428 }
2429
2430 void SwigDirector_ViewImpl::swig_init_callbacks() {
2431   swig_callbackOnStageConnection = 0;
2432   swig_callbackOnStageDisconnection = 0;
2433   swig_callbackOnChildAdd = 0;
2434   swig_callbackOnChildRemove = 0;
2435   swig_callbackOnPropertySet = 0;
2436   swig_callbackOnSizeSet = 0;
2437   swig_callbackOnSizeAnimation = 0;
2438   swig_callbackOnTouchEvent = 0;
2439   swig_callbackOnHoverEvent = 0;
2440   swig_callbackOnKeyEvent = 0;
2441   swig_callbackOnWheelEvent = 0;
2442   swig_callbackOnRelayout = 0;
2443   swig_callbackOnSetResizePolicy = 0;
2444   swig_callbackGetNaturalSize = 0;
2445   swig_callbackCalculateChildSize = 0;
2446   swig_callbackGetHeightForWidth = 0;
2447   swig_callbackGetWidthForHeight = 0;
2448   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2449   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2450   swig_callbackOnCalculateRelayoutSize = 0;
2451   swig_callbackOnLayoutNegotiated = 0;
2452   swig_callbackOnInitialize = 0;
2453   swig_callbackOnControlChildAdd = 0;
2454   swig_callbackOnControlChildRemove = 0;
2455   swig_callbackOnStyleChange = 0;
2456   swig_callbackOnAccessibilityActivated = 0;
2457   swig_callbackOnAccessibilityPan = 0;
2458   swig_callbackOnAccessibilityTouch = 0;
2459   swig_callbackOnAccessibilityValueChange = 0;
2460   swig_callbackOnAccessibilityZoom = 0;
2461   swig_callbackOnKeyInputFocusGained = 0;
2462   swig_callbackOnKeyInputFocusLost = 0;
2463   swig_callbackGetNextKeyboardFocusableActor = 0;
2464   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2465   swig_callbackOnKeyboardEnter = 0;
2466   swig_callbackOnPinch = 0;
2467   swig_callbackOnPan = 0;
2468   swig_callbackOnTap = 0;
2469   swig_callbackOnLongPress = 0;
2470   swig_callbackSignalConnected = 0;
2471   swig_callbackSignalDisconnected = 0;
2472 }
2473
2474 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2475   swig_init_callbacks();
2476 }
2477
2478 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2479
2480 }
2481
2482
2483 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2484   unsigned int c_result = SwigValueInit< unsigned int >() ;
2485   unsigned int jresult = 0 ;
2486
2487   if (!swig_callbackGetNumberOfItems) {
2488     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2489   } else {
2490     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2491     c_result = (unsigned int)jresult;
2492   }
2493   return c_result;
2494 }
2495
2496 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2497   Dali::Actor c_result ;
2498   void * jresult = 0 ;
2499   unsigned int jitemId  ;
2500
2501   if (!swig_callbackNewItem) {
2502     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2503   } else {
2504     jitemId = itemId;
2505     jresult = (void *) swig_callbackNewItem(jitemId);
2506     if (!jresult) {
2507       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2508       return c_result;
2509     }
2510     c_result = *(Dali::Actor *)jresult;
2511   }
2512   return c_result;
2513 }
2514
2515 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2516   unsigned int jitemId  ;
2517   void * jactor  ;
2518
2519   if (!swig_callbackItemReleased) {
2520     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2521     return;
2522   } else {
2523     jitemId = itemId;
2524     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2525     swig_callbackItemReleased(jitemId, jactor);
2526   }
2527 }
2528
2529 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2530   return Dali::Toolkit::ItemFactory::GetExtension();
2531 }
2532
2533 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2534   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2535   swig_callbackNewItem = callbackNewItem;
2536   swig_callbackItemReleased = callbackItemReleased;
2537 }
2538
2539 void SwigDirector_ItemFactory::swig_init_callbacks() {
2540   swig_callbackGetNumberOfItems = 0;
2541   swig_callbackNewItem = 0;
2542   swig_callbackItemReleased = 0;
2543 }
2544
2545 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2546   swig_init_callbacks();
2547 }
2548
2549 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2550
2551 }
2552
2553
2554 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2555   Dali::Actor c_result ;
2556   void * jresult = 0 ;
2557   void * jcurrent  ;
2558   void * jproposed  ;
2559   int jdirection  ;
2560
2561   if (!swig_callbackGetNextFocusableActor) {
2562     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2563   } else {
2564     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2565     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2566     jdirection = (int)direction;
2567     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2568     if (!jresult) {
2569       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2570       return c_result;
2571     }
2572     c_result = *(Dali::Actor *)jresult;
2573   }
2574   return c_result;
2575 }
2576
2577 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2578   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2579 }
2580
2581 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2582   swig_callbackGetNextFocusableActor = 0;
2583 }
2584
2585
2586 #ifdef __cplusplus
2587 extern "C" {
2588 #endif
2589
2590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2591   void * jresult ;
2592   floatp *result = 0 ;
2593
2594   {
2595     try {
2596       result = (floatp *)new_floatp();
2597     } catch (std::out_of_range& e) {
2598       {
2599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2600       };
2601     } catch (std::exception& e) {
2602       {
2603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2604       };
2605     } catch (DaliException e) {
2606       {
2607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2608       };
2609     } catch (...) {
2610       {
2611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2612       };
2613     }
2614   }
2615   jresult = (void *)result;
2616   return jresult;
2617 }
2618
2619
2620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2621   floatp *arg1 = (floatp *) 0 ;
2622
2623   arg1 = (floatp *)jarg1;
2624   {
2625     try {
2626       delete_floatp(arg1);
2627     } catch (std::out_of_range& e) {
2628       {
2629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2630       };
2631     } catch (std::exception& e) {
2632       {
2633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2634       };
2635     } catch (Dali::DaliException e) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2638       };
2639     } catch (...) {
2640       {
2641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2642       };
2643     }
2644   }
2645
2646 }
2647
2648
2649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2650   floatp *arg1 = (floatp *) 0 ;
2651   float arg2 ;
2652
2653   arg1 = (floatp *)jarg1;
2654   arg2 = (float)jarg2;
2655   {
2656     try {
2657       floatp_assign(arg1,arg2);
2658     } catch (std::out_of_range& e) {
2659       {
2660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2661       };
2662     } catch (std::exception& e) {
2663       {
2664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2665       };
2666     } catch (Dali::DaliException e) {
2667       {
2668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2669       };
2670     } catch (...) {
2671       {
2672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2673       };
2674     }
2675   }
2676
2677 }
2678
2679
2680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2681   float jresult ;
2682   floatp *arg1 = (floatp *) 0 ;
2683   float result;
2684
2685   arg1 = (floatp *)jarg1;
2686   {
2687     try {
2688       result = (float)floatp_value(arg1);
2689     } catch (std::out_of_range& e) {
2690       {
2691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2692       };
2693     } catch (std::exception& e) {
2694       {
2695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2696       };
2697     } catch (DaliException e) {
2698       {
2699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2700       };
2701     } catch (...) {
2702       {
2703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2704       };
2705     }
2706   }
2707   jresult = result;
2708   return jresult;
2709 }
2710
2711
2712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2713   void * jresult ;
2714   floatp *arg1 = (floatp *) 0 ;
2715   float *result = 0 ;
2716
2717   arg1 = (floatp *)jarg1;
2718   {
2719     try {
2720       result = (float *)floatp_cast(arg1);
2721     } catch (std::out_of_range& e) {
2722       {
2723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2724       };
2725     } catch (std::exception& e) {
2726       {
2727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2728       };
2729     } catch (Dali::DaliException e) {
2730       {
2731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2732       };
2733     } catch (...) {
2734       {
2735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2736       };
2737     }
2738   }
2739
2740   jresult = (void *)result;
2741   return jresult;
2742 }
2743
2744
2745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2746   void * jresult ;
2747   float *arg1 = (float *) 0 ;
2748   floatp *result = 0 ;
2749
2750   arg1 = (float *)jarg1;
2751   {
2752     try {
2753       result = (floatp *)floatp_frompointer(arg1);
2754     } catch (std::out_of_range& e) {
2755       {
2756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2757       };
2758     } catch (std::exception& e) {
2759       {
2760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2761       };
2762     } catch (Dali::DaliException e) {
2763       {
2764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2765       };
2766     } catch (...) {
2767       {
2768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2769       };
2770     }
2771   }
2772
2773   jresult = (void *)result;
2774   return jresult;
2775 }
2776
2777
2778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2779   void * jresult ;
2780   intp *result = 0 ;
2781
2782   {
2783     try {
2784       result = (intp *)new_intp();
2785     } catch (std::out_of_range& e) {
2786       {
2787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2788       };
2789     } catch (std::exception& e) {
2790       {
2791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2792       };
2793     } catch (Dali::DaliException e) {
2794       {
2795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2796       };
2797     } catch (...) {
2798       {
2799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2800       };
2801     }
2802   }
2803
2804   jresult = (void *)result;
2805   return jresult;
2806 }
2807
2808
2809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2810   intp *arg1 = (intp *) 0 ;
2811
2812   arg1 = (intp *)jarg1;
2813   {
2814     try {
2815       delete_intp(arg1);
2816     } catch (std::out_of_range& e) {
2817       {
2818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2819       };
2820     } catch (std::exception& e) {
2821       {
2822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2823       };
2824     } catch (Dali::DaliException e) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2827       };
2828     } catch (...) {
2829       {
2830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2831       };
2832     }
2833   }
2834
2835 }
2836
2837
2838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2839   intp *arg1 = (intp *) 0 ;
2840   int arg2 ;
2841
2842   arg1 = (intp *)jarg1;
2843   arg2 = (int)jarg2;
2844   {
2845     try {
2846       intp_assign(arg1,arg2);
2847     } catch (std::out_of_range& e) {
2848       {
2849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2850       };
2851     } catch (std::exception& e) {
2852       {
2853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2854       };
2855     } catch (Dali::DaliException e) {
2856       {
2857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2858       };
2859     } catch (...) {
2860       {
2861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2862       };
2863     }
2864   }
2865
2866 }
2867
2868
2869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2870   int jresult ;
2871   intp *arg1 = (intp *) 0 ;
2872   int result;
2873
2874   arg1 = (intp *)jarg1;
2875   {
2876     try {
2877       result = (int)intp_value(arg1);
2878     } catch (std::out_of_range& e) {
2879       {
2880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2881       };
2882     } catch (std::exception& e) {
2883       {
2884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2885       };
2886     } catch (Dali::DaliException e) {
2887       {
2888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2889       };
2890     } catch (...) {
2891       {
2892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2893       };
2894     }
2895   }
2896
2897   jresult = result;
2898   return jresult;
2899 }
2900
2901
2902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2903   void * jresult ;
2904   intp *arg1 = (intp *) 0 ;
2905   int *result = 0 ;
2906
2907   arg1 = (intp *)jarg1;
2908   {
2909     try {
2910       result = (int *)intp_cast(arg1);
2911     } catch (std::out_of_range& e) {
2912       {
2913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2914       };
2915     } catch (std::exception& e) {
2916       {
2917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2918       };
2919     } catch (Dali::DaliException e) {
2920       {
2921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2922       };
2923     } catch (...) {
2924       {
2925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2926       };
2927     }
2928   }
2929
2930   jresult = (void *)result;
2931   return jresult;
2932 }
2933
2934
2935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2936   void * jresult ;
2937   int *arg1 = (int *) 0 ;
2938   intp *result = 0 ;
2939
2940   arg1 = (int *)jarg1;
2941   {
2942     try {
2943       result = (intp *)intp_frompointer(arg1);
2944     } catch (std::out_of_range& e) {
2945       {
2946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2947       };
2948     } catch (std::exception& e) {
2949       {
2950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (Dali::DaliException e) {
2953       {
2954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2955       };
2956     } catch (...) {
2957       {
2958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2959       };
2960     }
2961   }
2962
2963   jresult = (void *)result;
2964   return jresult;
2965 }
2966
2967
2968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2969   void * jresult ;
2970   doublep *result = 0 ;
2971
2972   {
2973     try {
2974       result = (doublep *)new_doublep();
2975     } catch (std::out_of_range& e) {
2976       {
2977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2978       };
2979     } catch (std::exception& e) {
2980       {
2981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2982       };
2983     } catch (Dali::DaliException e) {
2984       {
2985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2986       };
2987     } catch (...) {
2988       {
2989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2990       };
2991     }
2992   }
2993
2994   jresult = (void *)result;
2995   return jresult;
2996 }
2997
2998
2999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3000   doublep *arg1 = (doublep *) 0 ;
3001
3002   arg1 = (doublep *)jarg1;
3003   {
3004     try {
3005       delete_doublep(arg1);
3006     } catch (std::out_of_range& e) {
3007       {
3008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3009       };
3010     } catch (std::exception& e) {
3011       {
3012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3013       };
3014     } catch (Dali::DaliException e) {
3015       {
3016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3017       };
3018     } catch (...) {
3019       {
3020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3021       };
3022     }
3023   }
3024
3025 }
3026
3027
3028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3029   doublep *arg1 = (doublep *) 0 ;
3030   double arg2 ;
3031
3032   arg1 = (doublep *)jarg1;
3033   arg2 = (double)jarg2;
3034   {
3035     try {
3036       doublep_assign(arg1,arg2);
3037     } catch (std::out_of_range& e) {
3038       {
3039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3040       };
3041     } catch (std::exception& e) {
3042       {
3043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3044       };
3045     } catch (Dali::DaliException e) {
3046       {
3047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3048       };
3049     } catch (...) {
3050       {
3051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3052       };
3053     }
3054   }
3055
3056 }
3057
3058
3059 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3060   double jresult ;
3061   doublep *arg1 = (doublep *) 0 ;
3062   double result;
3063
3064   arg1 = (doublep *)jarg1;
3065   {
3066     try {
3067       result = (double)doublep_value(arg1);
3068     } catch (std::out_of_range& e) {
3069       {
3070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3071       };
3072     } catch (std::exception& e) {
3073       {
3074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3075       };
3076     } catch (Dali::DaliException e) {
3077       {
3078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3079       };
3080     } catch (...) {
3081       {
3082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3083       };
3084     }
3085   }
3086
3087   jresult = result;
3088   return jresult;
3089 }
3090
3091
3092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3093   void * jresult ;
3094   doublep *arg1 = (doublep *) 0 ;
3095   double *result = 0 ;
3096
3097   arg1 = (doublep *)jarg1;
3098   {
3099     try {
3100       result = (double *)doublep_cast(arg1);
3101     } catch (std::out_of_range& e) {
3102       {
3103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3104       };
3105     } catch (std::exception& e) {
3106       {
3107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3108       };
3109     } catch (Dali::DaliException e) {
3110       {
3111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3112       };
3113     } catch (...) {
3114       {
3115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3116       };
3117     }
3118   }
3119
3120   jresult = (void *)result;
3121   return jresult;
3122 }
3123
3124
3125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3126   void * jresult ;
3127   double *arg1 = (double *) 0 ;
3128   doublep *result = 0 ;
3129
3130   arg1 = (double *)jarg1;
3131   {
3132     try {
3133       result = (doublep *)doublep_frompointer(arg1);
3134     } catch (std::out_of_range& e) {
3135       {
3136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (std::exception& e) {
3139       {
3140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3141       };
3142     } catch (Dali::DaliException e) {
3143       {
3144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3145       };
3146     } catch (...) {
3147       {
3148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3149       };
3150     }
3151   }
3152
3153   jresult = (void *)result;
3154   return jresult;
3155 }
3156
3157
3158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3159   void * jresult ;
3160   uintp *result = 0 ;
3161
3162   {
3163     try {
3164       result = (uintp *)new_uintp();
3165     } catch (std::out_of_range& e) {
3166       {
3167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3168       };
3169     } catch (std::exception& e) {
3170       {
3171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3172       };
3173     } catch (Dali::DaliException e) {
3174       {
3175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3176       };
3177     } catch (...) {
3178       {
3179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3180       };
3181     }
3182   }
3183
3184   jresult = (void *)result;
3185   return jresult;
3186 }
3187
3188
3189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3190   uintp *arg1 = (uintp *) 0 ;
3191
3192   arg1 = (uintp *)jarg1;
3193   {
3194     try {
3195       delete_uintp(arg1);
3196     } catch (std::out_of_range& e) {
3197       {
3198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3199       };
3200     } catch (std::exception& e) {
3201       {
3202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3203       };
3204     } catch (Dali::DaliException e) {
3205       {
3206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3207       };
3208     } catch (...) {
3209       {
3210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3211       };
3212     }
3213   }
3214
3215 }
3216
3217
3218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3219   uintp *arg1 = (uintp *) 0 ;
3220   unsigned int arg2 ;
3221
3222   arg1 = (uintp *)jarg1;
3223   arg2 = (unsigned int)jarg2;
3224   {
3225     try {
3226       uintp_assign(arg1,arg2);
3227     } catch (std::out_of_range& e) {
3228       {
3229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3230       };
3231     } catch (std::exception& e) {
3232       {
3233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3234       };
3235     } catch (Dali::DaliException e) {
3236       {
3237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3238       };
3239     } catch (...) {
3240       {
3241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3242       };
3243     }
3244   }
3245
3246 }
3247
3248
3249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3250   unsigned int jresult ;
3251   uintp *arg1 = (uintp *) 0 ;
3252   unsigned int result;
3253
3254   arg1 = (uintp *)jarg1;
3255   {
3256     try {
3257       result = (unsigned int)uintp_value(arg1);
3258     } catch (std::out_of_range& e) {
3259       {
3260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3261       };
3262     } catch (std::exception& e) {
3263       {
3264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3265       };
3266     } catch (Dali::DaliException e) {
3267       {
3268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3269       };
3270     } catch (...) {
3271       {
3272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3273       };
3274     }
3275   }
3276
3277   jresult = result;
3278   return jresult;
3279 }
3280
3281
3282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3283   void * jresult ;
3284   uintp *arg1 = (uintp *) 0 ;
3285   unsigned int *result = 0 ;
3286
3287   arg1 = (uintp *)jarg1;
3288   {
3289     try {
3290       result = (unsigned int *)uintp_cast(arg1);
3291     } catch (std::out_of_range& e) {
3292       {
3293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3294       };
3295     } catch (std::exception& e) {
3296       {
3297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3298       };
3299     } catch (Dali::DaliException e) {
3300       {
3301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3302       };
3303     } catch (...) {
3304       {
3305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3306       };
3307     }
3308   }
3309
3310   jresult = (void *)result;
3311   return jresult;
3312 }
3313
3314
3315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3316   void * jresult ;
3317   unsigned int *arg1 = (unsigned int *) 0 ;
3318   uintp *result = 0 ;
3319
3320   arg1 = (unsigned int *)jarg1;
3321   {
3322     try {
3323       result = (uintp *)uintp_frompointer(arg1);
3324     } catch (std::out_of_range& e) {
3325       {
3326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3327       };
3328     } catch (std::exception& e) {
3329       {
3330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3331       };
3332     } catch (Dali::DaliException e) {
3333       {
3334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3335       };
3336     } catch (...) {
3337       {
3338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3339       };
3340     }
3341   }
3342
3343   jresult = (void *)result;
3344   return jresult;
3345 }
3346
3347
3348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3349   void * jresult ;
3350   ushortp *result = 0 ;
3351
3352   {
3353     try {
3354       result = (ushortp *)new_ushortp();
3355     } catch (std::out_of_range& e) {
3356       {
3357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3358       };
3359     } catch (std::exception& e) {
3360       {
3361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3362       };
3363     } catch (Dali::DaliException e) {
3364       {
3365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3366       };
3367     } catch (...) {
3368       {
3369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3370       };
3371     }
3372   }
3373
3374   jresult = (void *)result;
3375   return jresult;
3376 }
3377
3378
3379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3380   ushortp *arg1 = (ushortp *) 0 ;
3381
3382   arg1 = (ushortp *)jarg1;
3383   {
3384     try {
3385       delete_ushortp(arg1);
3386     } catch (std::out_of_range& e) {
3387       {
3388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3389       };
3390     } catch (std::exception& e) {
3391       {
3392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3393       };
3394     } catch (Dali::DaliException e) {
3395       {
3396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3397       };
3398     } catch (...) {
3399       {
3400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3401       };
3402     }
3403   }
3404
3405 }
3406
3407
3408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3409   ushortp *arg1 = (ushortp *) 0 ;
3410   unsigned short arg2 ;
3411
3412   arg1 = (ushortp *)jarg1;
3413   arg2 = (unsigned short)jarg2;
3414   {
3415     try {
3416       ushortp_assign(arg1,arg2);
3417     } catch (std::out_of_range& e) {
3418       {
3419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3420       };
3421     } catch (std::exception& e) {
3422       {
3423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3424       };
3425     } catch (Dali::DaliException e) {
3426       {
3427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3428       };
3429     } catch (...) {
3430       {
3431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3432       };
3433     }
3434   }
3435
3436 }
3437
3438
3439 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3440   unsigned short jresult ;
3441   ushortp *arg1 = (ushortp *) 0 ;
3442   unsigned short result;
3443
3444   arg1 = (ushortp *)jarg1;
3445   {
3446     try {
3447       result = (unsigned short)ushortp_value(arg1);
3448     } catch (std::out_of_range& e) {
3449       {
3450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3451       };
3452     } catch (std::exception& e) {
3453       {
3454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3455       };
3456     } catch (Dali::DaliException e) {
3457       {
3458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3459       };
3460     } catch (...) {
3461       {
3462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3463       };
3464     }
3465   }
3466
3467   jresult = result;
3468   return jresult;
3469 }
3470
3471
3472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3473   void * jresult ;
3474   ushortp *arg1 = (ushortp *) 0 ;
3475   unsigned short *result = 0 ;
3476
3477   arg1 = (ushortp *)jarg1;
3478   {
3479     try {
3480       result = (unsigned short *)ushortp_cast(arg1);
3481     } catch (std::out_of_range& e) {
3482       {
3483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3484       };
3485     } catch (std::exception& e) {
3486       {
3487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3488       };
3489     } catch (Dali::DaliException e) {
3490       {
3491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3492       };
3493     } catch (...) {
3494       {
3495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3496       };
3497     }
3498   }
3499
3500   jresult = (void *)result;
3501   return jresult;
3502 }
3503
3504
3505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3506   void * jresult ;
3507   unsigned short *arg1 = (unsigned short *) 0 ;
3508   ushortp *result = 0 ;
3509
3510   arg1 = (unsigned short *)jarg1;
3511   {
3512     try {
3513       result = (ushortp *)ushortp_frompointer(arg1);
3514     } catch (std::out_of_range& e) {
3515       {
3516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3517       };
3518     } catch (std::exception& e) {
3519       {
3520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3521       };
3522     } catch (Dali::DaliException e) {
3523       {
3524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3525       };
3526     } catch (...) {
3527       {
3528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3529       };
3530     }
3531   }
3532
3533   jresult = (void *)result;
3534   return jresult;
3535 }
3536
3537
3538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3539   unsigned int jresult ;
3540   int arg1 ;
3541   unsigned int result;
3542
3543   arg1 = (int)jarg1;
3544   {
3545     try {
3546       result = (unsigned int)int_to_uint(arg1);
3547     } catch (std::out_of_range& e) {
3548       {
3549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3550       };
3551     } catch (std::exception& e) {
3552       {
3553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3554       };
3555     } catch (Dali::DaliException e) {
3556       {
3557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3558       };
3559     } catch (...) {
3560       {
3561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3562       };
3563     }
3564   }
3565
3566   jresult = result;
3567   return jresult;
3568 }
3569
3570
3571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3572   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3573
3574   arg1 = (Dali::RefObject *)jarg1;
3575   {
3576     try {
3577       (arg1)->Reference();
3578     } catch (std::out_of_range& e) {
3579       {
3580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3581       };
3582     } catch (std::exception& e) {
3583       {
3584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3585       };
3586     } catch (Dali::DaliException e) {
3587       {
3588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3589       };
3590     } catch (...) {
3591       {
3592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3593       };
3594     }
3595   }
3596
3597 }
3598
3599
3600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3601   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3602
3603   arg1 = (Dali::RefObject *)jarg1;
3604   {
3605     try {
3606       (arg1)->Unreference();
3607     } catch (std::out_of_range& e) {
3608       {
3609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3610       };
3611     } catch (std::exception& e) {
3612       {
3613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3614       };
3615     } catch (Dali::DaliException e) {
3616       {
3617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3618       };
3619     } catch (...) {
3620       {
3621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3622       };
3623     }
3624   }
3625
3626 }
3627
3628
3629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3630   int jresult ;
3631   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3632   int result;
3633
3634   arg1 = (Dali::RefObject *)jarg1;
3635   {
3636     try {
3637       result = (int)(arg1)->ReferenceCount();
3638     } catch (std::out_of_range& e) {
3639       {
3640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3641       };
3642     } catch (std::exception& e) {
3643       {
3644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3645       };
3646     } catch (Dali::DaliException e) {
3647       {
3648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3649       };
3650     } catch (...) {
3651       {
3652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3653       };
3654     }
3655   }
3656
3657   jresult = result;
3658   return jresult;
3659 }
3660
3661
3662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3663   void * jresult ;
3664   Dali::Any *result = 0 ;
3665
3666   {
3667     try {
3668       result = (Dali::Any *)new Dali::Any();
3669     } catch (std::out_of_range& e) {
3670       {
3671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3672       };
3673     } catch (std::exception& e) {
3674       {
3675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3676       };
3677     } catch (Dali::DaliException e) {
3678       {
3679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3680       };
3681     } catch (...) {
3682       {
3683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3684       };
3685     }
3686   }
3687
3688   jresult = (void *)result;
3689   return jresult;
3690 }
3691
3692
3693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3694   Dali::Any *arg1 = (Dali::Any *) 0 ;
3695
3696   arg1 = (Dali::Any *)jarg1;
3697   {
3698     try {
3699       delete arg1;
3700     } catch (std::out_of_range& e) {
3701       {
3702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3703       };
3704     } catch (std::exception& e) {
3705       {
3706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3707       };
3708     } catch (Dali::DaliException e) {
3709       {
3710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3711       };
3712     } catch (...) {
3713       {
3714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3715       };
3716     }
3717   }
3718
3719 }
3720
3721
3722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3723   char *arg1 = (char *) 0 ;
3724
3725   arg1 = (char *)jarg1;
3726   {
3727     try {
3728       Dali::Any::AssertAlways((char const *)arg1);
3729     } catch (std::out_of_range& e) {
3730       {
3731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3732       };
3733     } catch (std::exception& e) {
3734       {
3735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3736       };
3737     } catch (Dali::DaliException e) {
3738       {
3739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3740       };
3741     } catch (...) {
3742       {
3743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3744       };
3745     }
3746   }
3747
3748 }
3749
3750
3751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3752   void * jresult ;
3753   Dali::Any *arg1 = 0 ;
3754   Dali::Any *result = 0 ;
3755
3756   arg1 = (Dali::Any *)jarg1;
3757   if (!arg1) {
3758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3759     return 0;
3760   }
3761   {
3762     try {
3763       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3764     } catch (std::out_of_range& e) {
3765       {
3766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3767       };
3768     } catch (std::exception& e) {
3769       {
3770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3771       };
3772     } catch (Dali::DaliException e) {
3773       {
3774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3775       };
3776     } catch (...) {
3777       {
3778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3779       };
3780     }
3781   }
3782
3783   jresult = (void *)result;
3784   return jresult;
3785 }
3786
3787
3788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3789   void * jresult ;
3790   Dali::Any *arg1 = (Dali::Any *) 0 ;
3791   Dali::Any *arg2 = 0 ;
3792   Dali::Any *result = 0 ;
3793
3794   arg1 = (Dali::Any *)jarg1;
3795   arg2 = (Dali::Any *)jarg2;
3796   if (!arg2) {
3797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3798     return 0;
3799   }
3800   {
3801     try {
3802       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3803     } catch (std::out_of_range& e) {
3804       {
3805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3806       };
3807     } catch (std::exception& e) {
3808       {
3809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3810       };
3811     } catch (Dali::DaliException e) {
3812       {
3813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3814       };
3815     } catch (...) {
3816       {
3817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3818       };
3819     }
3820   }
3821
3822   jresult = (void *)result;
3823   return jresult;
3824 }
3825
3826
3827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3828   void * jresult ;
3829   Dali::Any *arg1 = (Dali::Any *) 0 ;
3830   std::type_info *result = 0 ;
3831
3832   arg1 = (Dali::Any *)jarg1;
3833   {
3834     try {
3835       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3836     } catch (std::out_of_range& e) {
3837       {
3838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3839       };
3840     } catch (std::exception& e) {
3841       {
3842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3843       };
3844     } catch (Dali::DaliException e) {
3845       {
3846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3847       };
3848     } catch (...) {
3849       {
3850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3851       };
3852     }
3853   }
3854
3855   jresult = (void *)result;
3856   return jresult;
3857 }
3858
3859
3860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3861   unsigned int jresult ;
3862   Dali::Any *arg1 = (Dali::Any *) 0 ;
3863   bool result;
3864
3865   arg1 = (Dali::Any *)jarg1;
3866   {
3867     try {
3868       result = (bool)((Dali::Any const *)arg1)->Empty();
3869     } catch (std::out_of_range& e) {
3870       {
3871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3872       };
3873     } catch (std::exception& e) {
3874       {
3875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3876       };
3877     } catch (Dali::DaliException e) {
3878       {
3879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3880       };
3881     } catch (...) {
3882       {
3883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3884       };
3885     }
3886   }
3887
3888   jresult = result;
3889   return jresult;
3890 }
3891
3892
3893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3894   void * jresult ;
3895   std::type_info *arg1 = 0 ;
3896   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3897   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3898   Dali::Any::AnyContainerBase *result = 0 ;
3899
3900   arg1 = (std::type_info *)jarg1;
3901   if (!arg1) {
3902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3903     return 0;
3904   }
3905   arg2 = (Dali::Any::CloneFunc)jarg2;
3906   arg3 = (Dali::Any::DeleteFunc)jarg3;
3907   {
3908     try {
3909       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3910     } catch (std::out_of_range& e) {
3911       {
3912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3913       };
3914     } catch (std::exception& e) {
3915       {
3916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3917       };
3918     } catch (Dali::DaliException e) {
3919       {
3920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3921       };
3922     } catch (...) {
3923       {
3924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3925       };
3926     }
3927   }
3928
3929   jresult = (void *)result;
3930   return jresult;
3931 }
3932
3933
3934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3935   void * jresult ;
3936   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3937   std::type_info *result = 0 ;
3938
3939   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3940   {
3941     try {
3942       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3943     } catch (std::out_of_range& e) {
3944       {
3945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3946       };
3947     } catch (std::exception& e) {
3948       {
3949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3950       };
3951     } catch (Dali::DaliException e) {
3952       {
3953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3954       };
3955     } catch (...) {
3956       {
3957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3958       };
3959     }
3960   }
3961
3962   jresult = (void *)result;
3963   return jresult;
3964 }
3965
3966
3967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3968   void * jresult ;
3969   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3970   ::std::type_info *result = 0 ;
3971
3972   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3973   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3974   jresult = (void *)result;
3975   return jresult;
3976 }
3977
3978
3979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3980   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3981   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3982
3983   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3984   arg2 = (Dali::Any::CloneFunc)jarg2;
3985   if (arg1) (arg1)->mCloneFunc = arg2;
3986 }
3987
3988
3989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3990   void * jresult ;
3991   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3992   Dali::Any::CloneFunc result;
3993
3994   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3995   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3996   jresult = (void *)result;
3997   return jresult;
3998 }
3999
4000
4001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4002   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4003   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4004
4005   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4006   arg2 = (Dali::Any::DeleteFunc)jarg2;
4007   if (arg1) (arg1)->mDeleteFunc = arg2;
4008 }
4009
4010
4011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4012   void * jresult ;
4013   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4014   Dali::Any::DeleteFunc result;
4015
4016   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4017   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4018   jresult = (void *)result;
4019   return jresult;
4020 }
4021
4022
4023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4024   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4025
4026   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4027   {
4028     try {
4029       delete arg1;
4030     } catch (std::out_of_range& e) {
4031       {
4032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4033       };
4034     } catch (std::exception& e) {
4035       {
4036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4037       };
4038     } catch (Dali::DaliException e) {
4039       {
4040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4041       };
4042     } catch (...) {
4043       {
4044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4045       };
4046     }
4047   }
4048
4049 }
4050
4051
4052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4053   Dali::Any *arg1 = (Dali::Any *) 0 ;
4054   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4055
4056   arg1 = (Dali::Any *)jarg1;
4057   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4058   if (arg1) (arg1)->mContainer = arg2;
4059 }
4060
4061
4062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4063   void * jresult ;
4064   Dali::Any *arg1 = (Dali::Any *) 0 ;
4065   Dali::Any::AnyContainerBase *result = 0 ;
4066
4067   arg1 = (Dali::Any *)jarg1;
4068   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4069   jresult = (void *)result;
4070   return jresult;
4071 }
4072
4073
4074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4075   char *arg1 = (char *) 0 ;
4076   char *arg2 = (char *) 0 ;
4077
4078   arg1 = (char *)jarg1;
4079   arg2 = (char *)jarg2;
4080   {
4081     try {
4082       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4083     } catch (std::out_of_range& e) {
4084       {
4085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4086       };
4087     } catch (std::exception& e) {
4088       {
4089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4090       };
4091     } catch (Dali::DaliException e) {
4092       {
4093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4094       };
4095     } catch (...) {
4096       {
4097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4098       };
4099     }
4100   }
4101
4102 }
4103
4104
4105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4106   void * jresult ;
4107   char *arg1 = (char *) 0 ;
4108   char *arg2 = (char *) 0 ;
4109   Dali::DaliException *result = 0 ;
4110
4111   arg1 = (char *)jarg1;
4112   arg2 = (char *)jarg2;
4113   {
4114     try {
4115       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4116     } catch (std::out_of_range& e) {
4117       {
4118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4119       };
4120     } catch (std::exception& e) {
4121       {
4122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4123       };
4124     } catch (Dali::DaliException e) {
4125       {
4126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4127       };
4128     } catch (...) {
4129       {
4130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4131       };
4132     }
4133   }
4134
4135   jresult = (void *)result;
4136   return jresult;
4137 }
4138
4139
4140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4141   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4142   std::string arg2 = std::string(jarg2);
4143
4144   arg1 = (Dali::DaliException *)jarg1;
4145   {
4146     if (!arg2.empty()) {
4147       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4148     } else {
4149       arg1->location = 0;
4150     }
4151   }
4152 }
4153
4154 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4155   char * jresult ;
4156   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4157   char *result = 0 ;
4158
4159   arg1 = (Dali::DaliException *)jarg1;
4160   result = (char *) ((arg1)->location);
4161   jresult = SWIG_csharp_string_callback((const char *)result);
4162   return jresult;
4163 }
4164
4165
4166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4167   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4168   std::string arg2 = std::string(jarg2);
4169
4170   arg1 = (Dali::DaliException *)jarg1;
4171   {
4172     if (!arg2.empty()) {
4173       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4174     } else {
4175       arg1->condition = 0;
4176     }
4177   }
4178 }
4179
4180
4181 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4182   char * jresult ;
4183   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4184   char *result = 0 ;
4185
4186   arg1 = (Dali::DaliException *)jarg1;
4187   result = (char *) ((arg1)->condition);
4188   jresult = SWIG_csharp_string_callback((const char *)result);
4189   return jresult;
4190 }
4191
4192
4193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4194   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4195
4196   arg1 = (Dali::DaliException *)jarg1;
4197   {
4198     try {
4199       delete arg1;
4200     } catch (std::out_of_range& e) {
4201       {
4202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4203       };
4204     } catch (std::exception& e) {
4205       {
4206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4207       };
4208     } catch (Dali::DaliException e) {
4209       {
4210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4211       };
4212     } catch (...) {
4213       {
4214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4215       };
4216     }
4217   }
4218
4219 }
4220
4221
4222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4223   void * jresult ;
4224   Dali::Vector2 *result = 0 ;
4225
4226   {
4227     try {
4228       result = (Dali::Vector2 *)new Dali::Vector2();
4229     } catch (std::out_of_range& e) {
4230       {
4231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4232       };
4233     } catch (std::exception& e) {
4234       {
4235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4236       };
4237     } catch (Dali::DaliException e) {
4238       {
4239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4240       };
4241     } catch (...) {
4242       {
4243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4244       };
4245     }
4246   }
4247
4248   jresult = (void *)result;
4249   return jresult;
4250 }
4251
4252
4253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4254   void * jresult ;
4255   float arg1 ;
4256   float arg2 ;
4257   Dali::Vector2 *result = 0 ;
4258
4259   arg1 = (float)jarg1;
4260   arg2 = (float)jarg2;
4261   {
4262     try {
4263       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4264     } catch (std::out_of_range& e) {
4265       {
4266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4267       };
4268     } catch (std::exception& e) {
4269       {
4270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4271       };
4272     } catch (Dali::DaliException e) {
4273       {
4274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4275       };
4276     } catch (...) {
4277       {
4278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4279       };
4280     }
4281   }
4282
4283   jresult = (void *)result;
4284   return jresult;
4285 }
4286
4287
4288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4289   void * jresult ;
4290   float *arg1 = (float *) 0 ;
4291   Dali::Vector2 *result = 0 ;
4292
4293   arg1 = jarg1;
4294   {
4295     try {
4296       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4297     } catch (std::out_of_range& e) {
4298       {
4299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4300       };
4301     } catch (std::exception& e) {
4302       {
4303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4304       };
4305     } catch (Dali::DaliException e) {
4306       {
4307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4308       };
4309     } catch (...) {
4310       {
4311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4312       };
4313     }
4314   }
4315
4316   jresult = (void *)result;
4317
4318
4319   return jresult;
4320 }
4321
4322
4323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4324   void * jresult ;
4325   Dali::Vector3 *arg1 = 0 ;
4326   Dali::Vector2 *result = 0 ;
4327
4328   arg1 = (Dali::Vector3 *)jarg1;
4329   if (!arg1) {
4330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4331     return 0;
4332   }
4333   {
4334     try {
4335       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4336     } catch (std::out_of_range& e) {
4337       {
4338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4339       };
4340     } catch (std::exception& e) {
4341       {
4342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4343       };
4344     } catch (Dali::DaliException e) {
4345       {
4346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4347       };
4348     } catch (...) {
4349       {
4350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4351       };
4352     }
4353   }
4354
4355   jresult = (void *)result;
4356   return jresult;
4357 }
4358
4359
4360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4361   void * jresult ;
4362   Dali::Vector4 *arg1 = 0 ;
4363   Dali::Vector2 *result = 0 ;
4364
4365   arg1 = (Dali::Vector4 *)jarg1;
4366   if (!arg1) {
4367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4368     return 0;
4369   }
4370   {
4371     try {
4372       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4373     } catch (std::out_of_range& e) {
4374       {
4375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4376       };
4377     } catch (std::exception& e) {
4378       {
4379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4380       };
4381     } catch (Dali::DaliException e) {
4382       {
4383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4384       };
4385     } catch (...) {
4386       {
4387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4388       };
4389     }
4390   }
4391
4392   jresult = (void *)result;
4393   return jresult;
4394 }
4395
4396
4397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4398   void * jresult ;
4399   Dali::Vector2 *result = 0 ;
4400
4401   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4402   jresult = (void *)result;
4403   return jresult;
4404 }
4405
4406
4407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4408   void * jresult ;
4409   Dali::Vector2 *result = 0 ;
4410
4411   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4412   jresult = (void *)result;
4413   return jresult;
4414 }
4415
4416
4417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4418   void * jresult ;
4419   Dali::Vector2 *result = 0 ;
4420
4421   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4422   jresult = (void *)result;
4423   return jresult;
4424 }
4425
4426
4427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4428   void * jresult ;
4429   Dali::Vector2 *result = 0 ;
4430
4431   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4432   jresult = (void *)result;
4433   return jresult;
4434 }
4435
4436
4437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4438   void * jresult ;
4439   Dali::Vector2 *result = 0 ;
4440
4441   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4442   jresult = (void *)result;
4443   return jresult;
4444 }
4445
4446
4447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4448   void * jresult ;
4449   Dali::Vector2 *result = 0 ;
4450
4451   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4452   jresult = (void *)result;
4453   return jresult;
4454 }
4455
4456
4457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4458   void * jresult ;
4459   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4460   float *arg2 = (float *) 0 ;
4461   Dali::Vector2 *result = 0 ;
4462
4463   arg1 = (Dali::Vector2 *)jarg1;
4464   arg2 = jarg2;
4465   {
4466     try {
4467       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4468     } catch (std::out_of_range& e) {
4469       {
4470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4471       };
4472     } catch (std::exception& e) {
4473       {
4474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4475       };
4476     } catch (Dali::DaliException e) {
4477       {
4478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4479       };
4480     } catch (...) {
4481       {
4482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4483       };
4484     }
4485   }
4486
4487   jresult = (void *)result;
4488
4489
4490   return jresult;
4491 }
4492
4493
4494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4495   void * jresult ;
4496   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4497   Dali::Vector3 *arg2 = 0 ;
4498   Dali::Vector2 *result = 0 ;
4499
4500   arg1 = (Dali::Vector2 *)jarg1;
4501   arg2 = (Dali::Vector3 *)jarg2;
4502   if (!arg2) {
4503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4504     return 0;
4505   }
4506   {
4507     try {
4508       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4509     } catch (std::out_of_range& e) {
4510       {
4511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4512       };
4513     } catch (std::exception& e) {
4514       {
4515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4516       };
4517     } catch (Dali::DaliException e) {
4518       {
4519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4520       };
4521     } catch (...) {
4522       {
4523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4524       };
4525     }
4526   }
4527
4528   jresult = (void *)result;
4529   return jresult;
4530 }
4531
4532
4533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4534   void * jresult ;
4535   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4536   Dali::Vector4 *arg2 = 0 ;
4537   Dali::Vector2 *result = 0 ;
4538
4539   arg1 = (Dali::Vector2 *)jarg1;
4540   arg2 = (Dali::Vector4 *)jarg2;
4541   if (!arg2) {
4542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4543     return 0;
4544   }
4545   {
4546     try {
4547       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4548     } catch (std::out_of_range& e) {
4549       {
4550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4551       };
4552     } catch (std::exception& e) {
4553       {
4554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4555       };
4556     } catch (Dali::DaliException e) {
4557       {
4558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4559       };
4560     } catch (...) {
4561       {
4562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4563       };
4564     }
4565   }
4566
4567   jresult = (void *)result;
4568   return jresult;
4569 }
4570
4571
4572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4573   void * jresult ;
4574   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4575   Dali::Vector2 *arg2 = 0 ;
4576   Dali::Vector2 result;
4577
4578   arg1 = (Dali::Vector2 *)jarg1;
4579   arg2 = (Dali::Vector2 *)jarg2;
4580   if (!arg2) {
4581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4582     return 0;
4583   }
4584   {
4585     try {
4586       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4587     } catch (std::out_of_range& e) {
4588       {
4589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4590       };
4591     } catch (std::exception& e) {
4592       {
4593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4594       };
4595     } catch (Dali::DaliException e) {
4596       {
4597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4598       };
4599     } catch (...) {
4600       {
4601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4602       };
4603     }
4604   }
4605
4606   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4607   return jresult;
4608 }
4609
4610
4611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4612   void * jresult ;
4613   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4614   Dali::Vector2 *arg2 = 0 ;
4615   Dali::Vector2 *result = 0 ;
4616
4617   arg1 = (Dali::Vector2 *)jarg1;
4618   arg2 = (Dali::Vector2 *)jarg2;
4619   if (!arg2) {
4620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4621     return 0;
4622   }
4623   {
4624     try {
4625       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4626     } catch (std::out_of_range& e) {
4627       {
4628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4629       };
4630     } catch (std::exception& e) {
4631       {
4632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4633       };
4634     } catch (Dali::DaliException e) {
4635       {
4636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4637       };
4638     } catch (...) {
4639       {
4640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4641       };
4642     }
4643   }
4644
4645   jresult = (void *)result;
4646   return jresult;
4647 }
4648
4649
4650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4651   void * jresult ;
4652   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4653   Dali::Vector2 *arg2 = 0 ;
4654   Dali::Vector2 result;
4655
4656   arg1 = (Dali::Vector2 *)jarg1;
4657   arg2 = (Dali::Vector2 *)jarg2;
4658   if (!arg2) {
4659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4660     return 0;
4661   }
4662   {
4663     try {
4664       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4665     } catch (std::out_of_range& e) {
4666       {
4667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4668       };
4669     } catch (std::exception& e) {
4670       {
4671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4672       };
4673     } catch (Dali::DaliException e) {
4674       {
4675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4676       };
4677     } catch (...) {
4678       {
4679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4680       };
4681     }
4682   }
4683
4684   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4685   return jresult;
4686 }
4687
4688
4689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4690   void * jresult ;
4691   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4692   Dali::Vector2 *arg2 = 0 ;
4693   Dali::Vector2 *result = 0 ;
4694
4695   arg1 = (Dali::Vector2 *)jarg1;
4696   arg2 = (Dali::Vector2 *)jarg2;
4697   if (!arg2) {
4698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4699     return 0;
4700   }
4701   {
4702     try {
4703       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4704     } catch (std::out_of_range& e) {
4705       {
4706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4707       };
4708     } catch (std::exception& e) {
4709       {
4710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4711       };
4712     } catch (Dali::DaliException e) {
4713       {
4714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4715       };
4716     } catch (...) {
4717       {
4718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4719       };
4720     }
4721   }
4722
4723   jresult = (void *)result;
4724   return jresult;
4725 }
4726
4727
4728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4729   void * jresult ;
4730   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4731   Dali::Vector2 *arg2 = 0 ;
4732   Dali::Vector2 result;
4733
4734   arg1 = (Dali::Vector2 *)jarg1;
4735   arg2 = (Dali::Vector2 *)jarg2;
4736   if (!arg2) {
4737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4738     return 0;
4739   }
4740   {
4741     try {
4742       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4743     } catch (std::out_of_range& e) {
4744       {
4745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4746       };
4747     } catch (std::exception& e) {
4748       {
4749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4750       };
4751     } catch (Dali::DaliException e) {
4752       {
4753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4754       };
4755     } catch (...) {
4756       {
4757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4758       };
4759     }
4760   }
4761
4762   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4763   return jresult;
4764 }
4765
4766
4767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4768   void * jresult ;
4769   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4770   float arg2 ;
4771   Dali::Vector2 result;
4772
4773   arg1 = (Dali::Vector2 *)jarg1;
4774   arg2 = (float)jarg2;
4775   {
4776     try {
4777       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4778     } catch (std::out_of_range& e) {
4779       {
4780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4781       };
4782     } catch (std::exception& e) {
4783       {
4784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4785       };
4786     } catch (Dali::DaliException e) {
4787       {
4788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4789       };
4790     } catch (...) {
4791       {
4792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4793       };
4794     }
4795   }
4796
4797   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4798   return jresult;
4799 }
4800
4801
4802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4803   void * jresult ;
4804   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4805   Dali::Vector2 *arg2 = 0 ;
4806   Dali::Vector2 *result = 0 ;
4807
4808   arg1 = (Dali::Vector2 *)jarg1;
4809   arg2 = (Dali::Vector2 *)jarg2;
4810   if (!arg2) {
4811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4812     return 0;
4813   }
4814   {
4815     try {
4816       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4817     } catch (std::out_of_range& e) {
4818       {
4819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4820       };
4821     } catch (std::exception& e) {
4822       {
4823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4824       };
4825     } catch (Dali::DaliException e) {
4826       {
4827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4828       };
4829     } catch (...) {
4830       {
4831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4832       };
4833     }
4834   }
4835
4836   jresult = (void *)result;
4837   return jresult;
4838 }
4839
4840
4841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4842   void * jresult ;
4843   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4844   float arg2 ;
4845   Dali::Vector2 *result = 0 ;
4846
4847   arg1 = (Dali::Vector2 *)jarg1;
4848   arg2 = (float)jarg2;
4849   {
4850     try {
4851       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4852     } catch (std::out_of_range& e) {
4853       {
4854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4855       };
4856     } catch (std::exception& e) {
4857       {
4858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4859       };
4860     } catch (Dali::DaliException e) {
4861       {
4862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4863       };
4864     } catch (...) {
4865       {
4866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4867       };
4868     }
4869   }
4870
4871   jresult = (void *)result;
4872   return jresult;
4873 }
4874
4875
4876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4877   void * jresult ;
4878   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4879   Dali::Vector2 *arg2 = 0 ;
4880   Dali::Vector2 result;
4881
4882   arg1 = (Dali::Vector2 *)jarg1;
4883   arg2 = (Dali::Vector2 *)jarg2;
4884   if (!arg2) {
4885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4886     return 0;
4887   }
4888   {
4889     try {
4890       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4891     } catch (std::out_of_range& e) {
4892       {
4893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4894       };
4895     } catch (std::exception& e) {
4896       {
4897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4898       };
4899     } catch (Dali::DaliException e) {
4900       {
4901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4902       };
4903     } catch (...) {
4904       {
4905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4906       };
4907     }
4908   }
4909
4910   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4911   return jresult;
4912 }
4913
4914
4915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4916   void * jresult ;
4917   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4918   float arg2 ;
4919   Dali::Vector2 result;
4920
4921   arg1 = (Dali::Vector2 *)jarg1;
4922   arg2 = (float)jarg2;
4923   {
4924     try {
4925       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4926     } catch (std::out_of_range& e) {
4927       {
4928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4929       };
4930     } catch (std::exception& e) {
4931       {
4932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4933       };
4934     } catch (Dali::DaliException e) {
4935       {
4936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4937       };
4938     } catch (...) {
4939       {
4940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4941       };
4942     }
4943   }
4944
4945   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4946   return jresult;
4947 }
4948
4949
4950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4951   void * jresult ;
4952   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4953   Dali::Vector2 *arg2 = 0 ;
4954   Dali::Vector2 *result = 0 ;
4955
4956   arg1 = (Dali::Vector2 *)jarg1;
4957   arg2 = (Dali::Vector2 *)jarg2;
4958   if (!arg2) {
4959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4960     return 0;
4961   }
4962   {
4963     try {
4964       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4965     } catch (std::out_of_range& e) {
4966       {
4967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4968       };
4969     } catch (std::exception& e) {
4970       {
4971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4972       };
4973     } catch (Dali::DaliException e) {
4974       {
4975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4976       };
4977     } catch (...) {
4978       {
4979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4980       };
4981     }
4982   }
4983
4984   jresult = (void *)result;
4985   return jresult;
4986 }
4987
4988
4989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4990   void * jresult ;
4991   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4992   float arg2 ;
4993   Dali::Vector2 *result = 0 ;
4994
4995   arg1 = (Dali::Vector2 *)jarg1;
4996   arg2 = (float)jarg2;
4997   {
4998     try {
4999       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5000     } catch (std::out_of_range& e) {
5001       {
5002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5003       };
5004     } catch (std::exception& e) {
5005       {
5006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5007       };
5008     } catch (Dali::DaliException e) {
5009       {
5010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5011       };
5012     } catch (...) {
5013       {
5014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5015       };
5016     }
5017   }
5018
5019   jresult = (void *)result;
5020   return jresult;
5021 }
5022
5023
5024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5025   void * jresult ;
5026   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5027   Dali::Vector2 result;
5028
5029   arg1 = (Dali::Vector2 *)jarg1;
5030   {
5031     try {
5032       result = ((Dali::Vector2 const *)arg1)->operator -();
5033     } catch (std::out_of_range& e) {
5034       {
5035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5036       };
5037     } catch (std::exception& e) {
5038       {
5039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5040       };
5041     } catch (Dali::DaliException e) {
5042       {
5043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5044       };
5045     } catch (...) {
5046       {
5047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5048       };
5049     }
5050   }
5051
5052   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5053   return jresult;
5054 }
5055
5056
5057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5058   unsigned int jresult ;
5059   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5060   Dali::Vector2 *arg2 = 0 ;
5061   bool result;
5062
5063   arg1 = (Dali::Vector2 *)jarg1;
5064   arg2 = (Dali::Vector2 *)jarg2;
5065   if (!arg2) {
5066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5067     return 0;
5068   }
5069   {
5070     try {
5071       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5072     } catch (std::out_of_range& e) {
5073       {
5074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5075       };
5076     } catch (std::exception& e) {
5077       {
5078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5079       };
5080     } catch (Dali::DaliException e) {
5081       {
5082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5083       };
5084     } catch (...) {
5085       {
5086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5087       };
5088     }
5089   }
5090
5091   jresult = result;
5092   return jresult;
5093 }
5094
5095
5096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5097   unsigned int jresult ;
5098   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5099   Dali::Vector2 *arg2 = 0 ;
5100   bool result;
5101
5102   arg1 = (Dali::Vector2 *)jarg1;
5103   arg2 = (Dali::Vector2 *)jarg2;
5104   if (!arg2) {
5105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5106     return 0;
5107   }
5108   {
5109     try {
5110       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5111     } catch (std::out_of_range& e) {
5112       {
5113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5114       };
5115     } catch (std::exception& e) {
5116       {
5117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5118       };
5119     } catch (Dali::DaliException e) {
5120       {
5121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5122       };
5123     } catch (...) {
5124       {
5125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5126       };
5127     }
5128   }
5129
5130   jresult = result;
5131   return jresult;
5132 }
5133
5134
5135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5136   float jresult ;
5137   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5138   unsigned int arg2 ;
5139   float *result = 0 ;
5140
5141   arg1 = (Dali::Vector2 *)jarg1;
5142   arg2 = (unsigned int)jarg2;
5143   {
5144     try {
5145       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5146     } catch (std::out_of_range& e) {
5147       {
5148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5149       };
5150     } catch (std::exception& e) {
5151       {
5152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5153       };
5154     } catch (Dali::DaliException e) {
5155       {
5156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5157       };
5158     } catch (...) {
5159       {
5160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5161       };
5162     }
5163   }
5164
5165   jresult = *result;
5166   return jresult;
5167 }
5168
5169
5170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5171   float jresult ;
5172   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5173   float result;
5174
5175   arg1 = (Dali::Vector2 *)jarg1;
5176   {
5177     try {
5178       result = (float)((Dali::Vector2 const *)arg1)->Length();
5179     } catch (std::out_of_range& e) {
5180       {
5181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5182       };
5183     } catch (std::exception& e) {
5184       {
5185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5186       };
5187     } catch (Dali::DaliException e) {
5188       {
5189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5190       };
5191     } catch (...) {
5192       {
5193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5194       };
5195     }
5196   }
5197
5198   jresult = result;
5199   return jresult;
5200 }
5201
5202
5203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5204   float jresult ;
5205   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5206   float result;
5207
5208   arg1 = (Dali::Vector2 *)jarg1;
5209   {
5210     try {
5211       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5212     } catch (std::out_of_range& e) {
5213       {
5214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5215       };
5216     } catch (std::exception& e) {
5217       {
5218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5219       };
5220     } catch (Dali::DaliException e) {
5221       {
5222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5223       };
5224     } catch (...) {
5225       {
5226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5227       };
5228     }
5229   }
5230
5231   jresult = result;
5232   return jresult;
5233 }
5234
5235
5236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5237   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5238
5239   arg1 = (Dali::Vector2 *)jarg1;
5240   {
5241     try {
5242       (arg1)->Normalize();
5243     } catch (std::out_of_range& e) {
5244       {
5245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5246       };
5247     } catch (std::exception& e) {
5248       {
5249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5250       };
5251     } catch (Dali::DaliException e) {
5252       {
5253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5254       };
5255     } catch (...) {
5256       {
5257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5258       };
5259     }
5260   }
5261
5262 }
5263
5264
5265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5266   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5267   Dali::Vector2 *arg2 = 0 ;
5268   Dali::Vector2 *arg3 = 0 ;
5269
5270   arg1 = (Dali::Vector2 *)jarg1;
5271   arg2 = (Dali::Vector2 *)jarg2;
5272   if (!arg2) {
5273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5274     return ;
5275   }
5276   arg3 = (Dali::Vector2 *)jarg3;
5277   if (!arg3) {
5278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5279     return ;
5280   }
5281   {
5282     try {
5283       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5284     } catch (std::out_of_range& e) {
5285       {
5286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5287       };
5288     } catch (std::exception& e) {
5289       {
5290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5291       };
5292     } catch (Dali::DaliException e) {
5293       {
5294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5295       };
5296     } catch (...) {
5297       {
5298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5299       };
5300     }
5301   }
5302
5303 }
5304
5305
5306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5307   void * jresult ;
5308   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5309   float *result = 0 ;
5310
5311   arg1 = (Dali::Vector2 *)jarg1;
5312   {
5313     try {
5314       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5315     } catch (std::out_of_range& e) {
5316       {
5317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5318       };
5319     } catch (std::exception& e) {
5320       {
5321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5322       };
5323     } catch (Dali::DaliException e) {
5324       {
5325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5326       };
5327     } catch (...) {
5328       {
5329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5330       };
5331     }
5332   }
5333
5334   jresult = (void *)result;
5335   return jresult;
5336 }
5337
5338
5339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5340   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5341   float arg2 ;
5342
5343   arg1 = (Dali::Vector2 *)jarg1;
5344   arg2 = (float)jarg2;
5345   if (arg1) (arg1)->x = arg2;
5346 }
5347
5348
5349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5350   float jresult ;
5351   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5352   float result;
5353
5354   arg1 = (Dali::Vector2 *)jarg1;
5355   result = (float) ((arg1)->x);
5356   jresult = result;
5357   return jresult;
5358 }
5359
5360
5361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5362   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5363   float arg2 ;
5364
5365   arg1 = (Dali::Vector2 *)jarg1;
5366   arg2 = (float)jarg2;
5367   if (arg1) (arg1)->width = arg2;
5368 }
5369
5370
5371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5372   float jresult ;
5373   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5374   float result;
5375
5376   arg1 = (Dali::Vector2 *)jarg1;
5377   result = (float) ((arg1)->width);
5378   jresult = result;
5379   return jresult;
5380 }
5381
5382
5383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5384   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5385   float arg2 ;
5386
5387   arg1 = (Dali::Vector2 *)jarg1;
5388   arg2 = (float)jarg2;
5389   if (arg1) (arg1)->y = arg2;
5390 }
5391
5392
5393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5394   float jresult ;
5395   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5396   float result;
5397
5398   arg1 = (Dali::Vector2 *)jarg1;
5399   result = (float) ((arg1)->y);
5400   jresult = result;
5401   return jresult;
5402 }
5403
5404
5405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5406   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5407   float arg2 ;
5408
5409   arg1 = (Dali::Vector2 *)jarg1;
5410   arg2 = (float)jarg2;
5411   if (arg1) (arg1)->height = arg2;
5412 }
5413
5414
5415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5416   float jresult ;
5417   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5418   float result;
5419
5420   arg1 = (Dali::Vector2 *)jarg1;
5421   result = (float) ((arg1)->height);
5422   jresult = result;
5423   return jresult;
5424 }
5425
5426
5427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5428   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5429
5430   arg1 = (Dali::Vector2 *)jarg1;
5431   {
5432     try {
5433       delete arg1;
5434     } catch (std::out_of_range& e) {
5435       {
5436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5437       };
5438     } catch (std::exception& e) {
5439       {
5440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5441       };
5442     } catch (Dali::DaliException e) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5445       };
5446     } catch (...) {
5447       {
5448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5449       };
5450     }
5451   }
5452
5453 }
5454
5455
5456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5457   void * jresult ;
5458   Dali::Vector2 *arg1 = 0 ;
5459   Dali::Vector2 *arg2 = 0 ;
5460   Dali::Vector2 result;
5461
5462   arg1 = (Dali::Vector2 *)jarg1;
5463   if (!arg1) {
5464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5465     return 0;
5466   }
5467   arg2 = (Dali::Vector2 *)jarg2;
5468   if (!arg2) {
5469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5470     return 0;
5471   }
5472   {
5473     try {
5474       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5475     } catch (std::out_of_range& e) {
5476       {
5477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5478       };
5479     } catch (std::exception& e) {
5480       {
5481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5482       };
5483     } catch (Dali::DaliException e) {
5484       {
5485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5486       };
5487     } catch (...) {
5488       {
5489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5490       };
5491     }
5492   }
5493
5494   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5495   return jresult;
5496 }
5497
5498
5499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5500   void * jresult ;
5501   Dali::Vector2 *arg1 = 0 ;
5502   Dali::Vector2 *arg2 = 0 ;
5503   Dali::Vector2 result;
5504
5505   arg1 = (Dali::Vector2 *)jarg1;
5506   if (!arg1) {
5507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5508     return 0;
5509   }
5510   arg2 = (Dali::Vector2 *)jarg2;
5511   if (!arg2) {
5512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5513     return 0;
5514   }
5515   {
5516     try {
5517       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5518     } catch (std::out_of_range& e) {
5519       {
5520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5521       };
5522     } catch (std::exception& e) {
5523       {
5524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5525       };
5526     } catch (Dali::DaliException e) {
5527       {
5528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5529       };
5530     } catch (...) {
5531       {
5532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5533       };
5534     }
5535   }
5536
5537   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5538   return jresult;
5539 }
5540
5541
5542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5543   void * jresult ;
5544   Dali::Vector2 *arg1 = 0 ;
5545   float *arg2 = 0 ;
5546   float *arg3 = 0 ;
5547   float temp2 ;
5548   float temp3 ;
5549   Dali::Vector2 result;
5550
5551   arg1 = (Dali::Vector2 *)jarg1;
5552   if (!arg1) {
5553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5554     return 0;
5555   }
5556   temp2 = (float)jarg2;
5557   arg2 = &temp2;
5558   temp3 = (float)jarg3;
5559   arg3 = &temp3;
5560   {
5561     try {
5562       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5563     } catch (std::out_of_range& e) {
5564       {
5565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5566       };
5567     } catch (std::exception& e) {
5568       {
5569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5570       };
5571     } catch (Dali::DaliException e) {
5572       {
5573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5574       };
5575     } catch (...) {
5576       {
5577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5578       };
5579     }
5580   }
5581
5582   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5583   return jresult;
5584 }
5585
5586
5587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5588   void * jresult ;
5589   Dali::Vector3 *result = 0 ;
5590
5591   {
5592     try {
5593       result = (Dali::Vector3 *)new Dali::Vector3();
5594     } catch (std::out_of_range& e) {
5595       {
5596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5597       };
5598     } catch (std::exception& e) {
5599       {
5600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5601       };
5602     } catch (Dali::DaliException e) {
5603       {
5604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5605       };
5606     } catch (...) {
5607       {
5608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5609       };
5610     }
5611   }
5612
5613   jresult = (void *)result;
5614   return jresult;
5615 }
5616
5617
5618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5619   void * jresult ;
5620   float arg1 ;
5621   float arg2 ;
5622   float arg3 ;
5623   Dali::Vector3 *result = 0 ;
5624
5625   arg1 = (float)jarg1;
5626   arg2 = (float)jarg2;
5627   arg3 = (float)jarg3;
5628   {
5629     try {
5630       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5631     } catch (std::out_of_range& e) {
5632       {
5633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5634       };
5635     } catch (std::exception& e) {
5636       {
5637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5638       };
5639     } catch (Dali::DaliException e) {
5640       {
5641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5642       };
5643     } catch (...) {
5644       {
5645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5646       };
5647     }
5648   }
5649
5650   jresult = (void *)result;
5651   return jresult;
5652 }
5653
5654
5655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5656   void * jresult ;
5657   float *arg1 = (float *) 0 ;
5658   Dali::Vector3 *result = 0 ;
5659
5660   arg1 = jarg1;
5661   {
5662     try {
5663       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5664     } catch (std::out_of_range& e) {
5665       {
5666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5667       };
5668     } catch (std::exception& e) {
5669       {
5670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5671       };
5672     } catch (Dali::DaliException e) {
5673       {
5674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5675       };
5676     } catch (...) {
5677       {
5678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5679       };
5680     }
5681   }
5682
5683   jresult = (void *)result;
5684
5685
5686   return jresult;
5687 }
5688
5689
5690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5691   void * jresult ;
5692   Dali::Vector2 *arg1 = 0 ;
5693   Dali::Vector3 *result = 0 ;
5694
5695   arg1 = (Dali::Vector2 *)jarg1;
5696   if (!arg1) {
5697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5698     return 0;
5699   }
5700   {
5701     try {
5702       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5703     } catch (std::out_of_range& e) {
5704       {
5705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5706       };
5707     } catch (std::exception& e) {
5708       {
5709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5710       };
5711     } catch (Dali::DaliException e) {
5712       {
5713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5714       };
5715     } catch (...) {
5716       {
5717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5718       };
5719     }
5720   }
5721
5722   jresult = (void *)result;
5723   return jresult;
5724 }
5725
5726
5727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5728   void * jresult ;
5729   Dali::Vector4 *arg1 = 0 ;
5730   Dali::Vector3 *result = 0 ;
5731
5732   arg1 = (Dali::Vector4 *)jarg1;
5733   if (!arg1) {
5734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5735     return 0;
5736   }
5737   {
5738     try {
5739       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5740     } catch (std::out_of_range& e) {
5741       {
5742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5743       };
5744     } catch (std::exception& e) {
5745       {
5746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5747       };
5748     } catch (Dali::DaliException e) {
5749       {
5750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5751       };
5752     } catch (...) {
5753       {
5754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5755       };
5756     }
5757   }
5758
5759   jresult = (void *)result;
5760   return jresult;
5761 }
5762
5763
5764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5765   void * jresult ;
5766   Dali::Vector3 *result = 0 ;
5767
5768   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5769   jresult = (void *)result;
5770   return jresult;
5771 }
5772
5773
5774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5775   void * jresult ;
5776   Dali::Vector3 *result = 0 ;
5777
5778   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5779   jresult = (void *)result;
5780   return jresult;
5781 }
5782
5783
5784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5785   void * jresult ;
5786   Dali::Vector3 *result = 0 ;
5787
5788   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5789   jresult = (void *)result;
5790   return jresult;
5791 }
5792
5793
5794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5795   void * jresult ;
5796   Dali::Vector3 *result = 0 ;
5797
5798   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5799   jresult = (void *)result;
5800   return jresult;
5801 }
5802
5803
5804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5805   void * jresult ;
5806   Dali::Vector3 *result = 0 ;
5807
5808   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5809   jresult = (void *)result;
5810   return jresult;
5811 }
5812
5813
5814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5815   void * jresult ;
5816   Dali::Vector3 *result = 0 ;
5817
5818   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5819   jresult = (void *)result;
5820   return jresult;
5821 }
5822
5823
5824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5825   void * jresult ;
5826   Dali::Vector3 *result = 0 ;
5827
5828   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5829   jresult = (void *)result;
5830   return jresult;
5831 }
5832
5833
5834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5835   void * jresult ;
5836   Dali::Vector3 *result = 0 ;
5837
5838   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5839   jresult = (void *)result;
5840   return jresult;
5841 }
5842
5843
5844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5845   void * jresult ;
5846   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5847   float *arg2 = (float *) 0 ;
5848   Dali::Vector3 *result = 0 ;
5849
5850   arg1 = (Dali::Vector3 *)jarg1;
5851   arg2 = jarg2;
5852   {
5853     try {
5854       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5855     } catch (std::out_of_range& e) {
5856       {
5857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5858       };
5859     } catch (std::exception& e) {
5860       {
5861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5862       };
5863     } catch (Dali::DaliException e) {
5864       {
5865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5866       };
5867     } catch (...) {
5868       {
5869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5870       };
5871     }
5872   }
5873
5874   jresult = (void *)result;
5875
5876
5877   return jresult;
5878 }
5879
5880
5881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5882   void * jresult ;
5883   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5884   Dali::Vector2 *arg2 = 0 ;
5885   Dali::Vector3 *result = 0 ;
5886
5887   arg1 = (Dali::Vector3 *)jarg1;
5888   arg2 = (Dali::Vector2 *)jarg2;
5889   if (!arg2) {
5890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5891     return 0;
5892   }
5893   {
5894     try {
5895       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5896     } catch (std::out_of_range& e) {
5897       {
5898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5899       };
5900     } catch (std::exception& e) {
5901       {
5902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5903       };
5904     } catch (Dali::DaliException e) {
5905       {
5906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5907       };
5908     } catch (...) {
5909       {
5910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5911       };
5912     }
5913   }
5914
5915   jresult = (void *)result;
5916   return jresult;
5917 }
5918
5919
5920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5921   void * jresult ;
5922   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5923   Dali::Vector4 *arg2 = 0 ;
5924   Dali::Vector3 *result = 0 ;
5925
5926   arg1 = (Dali::Vector3 *)jarg1;
5927   arg2 = (Dali::Vector4 *)jarg2;
5928   if (!arg2) {
5929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5930     return 0;
5931   }
5932   {
5933     try {
5934       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5935     } catch (std::out_of_range& e) {
5936       {
5937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5938       };
5939     } catch (std::exception& e) {
5940       {
5941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5942       };
5943     } catch (Dali::DaliException e) {
5944       {
5945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5946       };
5947     } catch (...) {
5948       {
5949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5950       };
5951     }
5952   }
5953
5954   jresult = (void *)result;
5955   return jresult;
5956 }
5957
5958
5959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5960   void * jresult ;
5961   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5962   Dali::Vector3 *arg2 = 0 ;
5963   Dali::Vector3 result;
5964
5965   arg1 = (Dali::Vector3 *)jarg1;
5966   arg2 = (Dali::Vector3 *)jarg2;
5967   if (!arg2) {
5968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5969     return 0;
5970   }
5971   {
5972     try {
5973       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5974     } catch (std::out_of_range& e) {
5975       {
5976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5977       };
5978     } catch (std::exception& e) {
5979       {
5980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5981       };
5982     } catch (Dali::DaliException e) {
5983       {
5984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5985       };
5986     } catch (...) {
5987       {
5988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5989       };
5990     }
5991   }
5992
5993   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5994   return jresult;
5995 }
5996
5997
5998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5999   void * jresult ;
6000   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6001   Dali::Vector3 *arg2 = 0 ;
6002   Dali::Vector3 *result = 0 ;
6003
6004   arg1 = (Dali::Vector3 *)jarg1;
6005   arg2 = (Dali::Vector3 *)jarg2;
6006   if (!arg2) {
6007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6008     return 0;
6009   }
6010   {
6011     try {
6012       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6013     } catch (std::out_of_range& e) {
6014       {
6015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6016       };
6017     } catch (std::exception& e) {
6018       {
6019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6020       };
6021     } catch (Dali::DaliException e) {
6022       {
6023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6024       };
6025     } catch (...) {
6026       {
6027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6028       };
6029     }
6030   }
6031
6032   jresult = (void *)result;
6033   return jresult;
6034 }
6035
6036
6037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6038   void * jresult ;
6039   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6040   Dali::Vector3 *arg2 = 0 ;
6041   Dali::Vector3 result;
6042
6043   arg1 = (Dali::Vector3 *)jarg1;
6044   arg2 = (Dali::Vector3 *)jarg2;
6045   if (!arg2) {
6046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6047     return 0;
6048   }
6049   {
6050     try {
6051       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6052     } catch (std::out_of_range& e) {
6053       {
6054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6055       };
6056     } catch (std::exception& e) {
6057       {
6058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6059       };
6060     } catch (Dali::DaliException e) {
6061       {
6062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6063       };
6064     } catch (...) {
6065       {
6066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6067       };
6068     }
6069   }
6070
6071   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6072   return jresult;
6073 }
6074
6075
6076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6077   void * jresult ;
6078   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6079   Dali::Vector3 *arg2 = 0 ;
6080   Dali::Vector3 *result = 0 ;
6081
6082   arg1 = (Dali::Vector3 *)jarg1;
6083   arg2 = (Dali::Vector3 *)jarg2;
6084   if (!arg2) {
6085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6086     return 0;
6087   }
6088   {
6089     try {
6090       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6091     } catch (std::out_of_range& e) {
6092       {
6093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6094       };
6095     } catch (std::exception& e) {
6096       {
6097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6098       };
6099     } catch (Dali::DaliException e) {
6100       {
6101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6102       };
6103     } catch (...) {
6104       {
6105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6106       };
6107     }
6108   }
6109
6110   jresult = (void *)result;
6111   return jresult;
6112 }
6113
6114
6115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6116   void * jresult ;
6117   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6118   Dali::Vector3 *arg2 = 0 ;
6119   Dali::Vector3 result;
6120
6121   arg1 = (Dali::Vector3 *)jarg1;
6122   arg2 = (Dali::Vector3 *)jarg2;
6123   if (!arg2) {
6124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6125     return 0;
6126   }
6127   {
6128     try {
6129       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6130     } catch (std::out_of_range& e) {
6131       {
6132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6133       };
6134     } catch (std::exception& e) {
6135       {
6136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6137       };
6138     } catch (Dali::DaliException e) {
6139       {
6140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6141       };
6142     } catch (...) {
6143       {
6144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6145       };
6146     }
6147   }
6148
6149   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6150   return jresult;
6151 }
6152
6153
6154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6155   void * jresult ;
6156   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6157   float arg2 ;
6158   Dali::Vector3 result;
6159
6160   arg1 = (Dali::Vector3 *)jarg1;
6161   arg2 = (float)jarg2;
6162   {
6163     try {
6164       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6165     } catch (std::out_of_range& e) {
6166       {
6167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6168       };
6169     } catch (std::exception& e) {
6170       {
6171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6172       };
6173     } catch (Dali::DaliException e) {
6174       {
6175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6176       };
6177     } catch (...) {
6178       {
6179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6180       };
6181     }
6182   }
6183
6184   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6185   return jresult;
6186 }
6187
6188
6189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6190   void * jresult ;
6191   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6192   Dali::Vector3 *arg2 = 0 ;
6193   Dali::Vector3 *result = 0 ;
6194
6195   arg1 = (Dali::Vector3 *)jarg1;
6196   arg2 = (Dali::Vector3 *)jarg2;
6197   if (!arg2) {
6198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6199     return 0;
6200   }
6201   {
6202     try {
6203       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6204     } catch (std::out_of_range& e) {
6205       {
6206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6207       };
6208     } catch (std::exception& e) {
6209       {
6210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6211       };
6212     } catch (Dali::DaliException e) {
6213       {
6214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6215       };
6216     } catch (...) {
6217       {
6218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6219       };
6220     }
6221   }
6222
6223   jresult = (void *)result;
6224   return jresult;
6225 }
6226
6227
6228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6229   void * jresult ;
6230   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6231   float arg2 ;
6232   Dali::Vector3 *result = 0 ;
6233
6234   arg1 = (Dali::Vector3 *)jarg1;
6235   arg2 = (float)jarg2;
6236   {
6237     try {
6238       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6239     } catch (std::out_of_range& e) {
6240       {
6241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6242       };
6243     } catch (std::exception& e) {
6244       {
6245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6246       };
6247     } catch (Dali::DaliException e) {
6248       {
6249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6250       };
6251     } catch (...) {
6252       {
6253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6254       };
6255     }
6256   }
6257
6258   jresult = (void *)result;
6259   return jresult;
6260 }
6261
6262
6263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6264   void * jresult ;
6265   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6266   Dali::Quaternion *arg2 = 0 ;
6267   Dali::Vector3 *result = 0 ;
6268
6269   arg1 = (Dali::Vector3 *)jarg1;
6270   arg2 = (Dali::Quaternion *)jarg2;
6271   if (!arg2) {
6272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6273     return 0;
6274   }
6275   {
6276     try {
6277       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6278     } catch (std::out_of_range& e) {
6279       {
6280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6281       };
6282     } catch (std::exception& e) {
6283       {
6284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6285       };
6286     } catch (Dali::DaliException e) {
6287       {
6288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6289       };
6290     } catch (...) {
6291       {
6292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6293       };
6294     }
6295   }
6296
6297   jresult = (void *)result;
6298   return jresult;
6299 }
6300
6301
6302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6303   void * jresult ;
6304   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6305   Dali::Vector3 *arg2 = 0 ;
6306   Dali::Vector3 result;
6307
6308   arg1 = (Dali::Vector3 *)jarg1;
6309   arg2 = (Dali::Vector3 *)jarg2;
6310   if (!arg2) {
6311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6312     return 0;
6313   }
6314   {
6315     try {
6316       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6317     } catch (std::out_of_range& e) {
6318       {
6319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6320       };
6321     } catch (std::exception& e) {
6322       {
6323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6324       };
6325     } catch (Dali::DaliException e) {
6326       {
6327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6328       };
6329     } catch (...) {
6330       {
6331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6332       };
6333     }
6334   }
6335
6336   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6337   return jresult;
6338 }
6339
6340
6341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6342   void * jresult ;
6343   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6344   float arg2 ;
6345   Dali::Vector3 result;
6346
6347   arg1 = (Dali::Vector3 *)jarg1;
6348   arg2 = (float)jarg2;
6349   {
6350     try {
6351       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6352     } catch (std::out_of_range& e) {
6353       {
6354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6355       };
6356     } catch (std::exception& e) {
6357       {
6358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6359       };
6360     } catch (Dali::DaliException e) {
6361       {
6362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6363       };
6364     } catch (...) {
6365       {
6366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6367       };
6368     }
6369   }
6370
6371   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6372   return jresult;
6373 }
6374
6375
6376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6377   void * jresult ;
6378   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6379   Dali::Vector3 *arg2 = 0 ;
6380   Dali::Vector3 *result = 0 ;
6381
6382   arg1 = (Dali::Vector3 *)jarg1;
6383   arg2 = (Dali::Vector3 *)jarg2;
6384   if (!arg2) {
6385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6386     return 0;
6387   }
6388   {
6389     try {
6390       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6391     } catch (std::out_of_range& e) {
6392       {
6393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6394       };
6395     } catch (std::exception& e) {
6396       {
6397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6398       };
6399     } catch (Dali::DaliException e) {
6400       {
6401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6402       };
6403     } catch (...) {
6404       {
6405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6406       };
6407     }
6408   }
6409
6410   jresult = (void *)result;
6411   return jresult;
6412 }
6413
6414
6415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6416   void * jresult ;
6417   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6418   float arg2 ;
6419   Dali::Vector3 *result = 0 ;
6420
6421   arg1 = (Dali::Vector3 *)jarg1;
6422   arg2 = (float)jarg2;
6423   {
6424     try {
6425       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6426     } catch (std::out_of_range& e) {
6427       {
6428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6429       };
6430     } catch (std::exception& e) {
6431       {
6432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6433       };
6434     } catch (Dali::DaliException e) {
6435       {
6436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6437       };
6438     } catch (...) {
6439       {
6440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6441       };
6442     }
6443   }
6444
6445   jresult = (void *)result;
6446   return jresult;
6447 }
6448
6449
6450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6451   void * jresult ;
6452   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6453   Dali::Vector3 result;
6454
6455   arg1 = (Dali::Vector3 *)jarg1;
6456   {
6457     try {
6458       result = ((Dali::Vector3 const *)arg1)->operator -();
6459     } catch (std::out_of_range& e) {
6460       {
6461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6462       };
6463     } catch (std::exception& e) {
6464       {
6465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6466       };
6467     } catch (Dali::DaliException e) {
6468       {
6469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6470       };
6471     } catch (...) {
6472       {
6473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6474       };
6475     }
6476   }
6477
6478   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6479   return jresult;
6480 }
6481
6482
6483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6484   unsigned int jresult ;
6485   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6486   Dali::Vector3 *arg2 = 0 ;
6487   bool result;
6488
6489   arg1 = (Dali::Vector3 *)jarg1;
6490   arg2 = (Dali::Vector3 *)jarg2;
6491   if (!arg2) {
6492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6493     return 0;
6494   }
6495   {
6496     try {
6497       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6498     } catch (std::out_of_range& e) {
6499       {
6500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6501       };
6502     } catch (std::exception& e) {
6503       {
6504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6505       };
6506     } catch (Dali::DaliException e) {
6507       {
6508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6509       };
6510     } catch (...) {
6511       {
6512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6513       };
6514     }
6515   }
6516
6517   jresult = result;
6518   return jresult;
6519 }
6520
6521
6522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6523   unsigned int jresult ;
6524   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6525   Dali::Vector3 *arg2 = 0 ;
6526   bool result;
6527
6528   arg1 = (Dali::Vector3 *)jarg1;
6529   arg2 = (Dali::Vector3 *)jarg2;
6530   if (!arg2) {
6531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6532     return 0;
6533   }
6534   {
6535     try {
6536       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6537     } catch (std::out_of_range& e) {
6538       {
6539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6540       };
6541     } catch (std::exception& e) {
6542       {
6543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6544       };
6545     } catch (Dali::DaliException e) {
6546       {
6547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6548       };
6549     } catch (...) {
6550       {
6551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6552       };
6553     }
6554   }
6555
6556   jresult = result;
6557   return jresult;
6558 }
6559
6560
6561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6562   float jresult ;
6563   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6564   unsigned int arg2 ;
6565   float *result = 0 ;
6566
6567   arg1 = (Dali::Vector3 *)jarg1;
6568   arg2 = (unsigned int)jarg2;
6569   {
6570     try {
6571       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6572     } catch (std::out_of_range& e) {
6573       {
6574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6575       };
6576     } catch (std::exception& e) {
6577       {
6578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6579       };
6580     } catch (Dali::DaliException e) {
6581       {
6582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6583       };
6584     } catch (...) {
6585       {
6586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6587       };
6588     }
6589   }
6590
6591   jresult = *result;
6592   return jresult;
6593 }
6594
6595
6596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6597   float jresult ;
6598   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6599   Dali::Vector3 *arg2 = 0 ;
6600   float result;
6601
6602   arg1 = (Dali::Vector3 *)jarg1;
6603   arg2 = (Dali::Vector3 *)jarg2;
6604   if (!arg2) {
6605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6606     return 0;
6607   }
6608   {
6609     try {
6610       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6611     } catch (std::out_of_range& e) {
6612       {
6613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6614       };
6615     } catch (std::exception& e) {
6616       {
6617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6618       };
6619     } catch (Dali::DaliException e) {
6620       {
6621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6622       };
6623     } catch (...) {
6624       {
6625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6626       };
6627     }
6628   }
6629
6630   jresult = result;
6631   return jresult;
6632 }
6633
6634
6635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6636   void * jresult ;
6637   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6638   Dali::Vector3 *arg2 = 0 ;
6639   Dali::Vector3 result;
6640
6641   arg1 = (Dali::Vector3 *)jarg1;
6642   arg2 = (Dali::Vector3 *)jarg2;
6643   if (!arg2) {
6644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6645     return 0;
6646   }
6647   {
6648     try {
6649       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6650     } catch (std::out_of_range& e) {
6651       {
6652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6653       };
6654     } catch (std::exception& e) {
6655       {
6656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6657       };
6658     } catch (Dali::DaliException e) {
6659       {
6660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6661       };
6662     } catch (...) {
6663       {
6664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6665       };
6666     }
6667   }
6668
6669   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6670   return jresult;
6671 }
6672
6673
6674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6675   float jresult ;
6676   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6677   float result;
6678
6679   arg1 = (Dali::Vector3 *)jarg1;
6680   {
6681     try {
6682       result = (float)((Dali::Vector3 const *)arg1)->Length();
6683     } catch (std::out_of_range& e) {
6684       {
6685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6686       };
6687     } catch (std::exception& e) {
6688       {
6689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6690       };
6691     } catch (Dali::DaliException e) {
6692       {
6693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6694       };
6695     } catch (...) {
6696       {
6697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6698       };
6699     }
6700   }
6701
6702   jresult = result;
6703   return jresult;
6704 }
6705
6706
6707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6708   float jresult ;
6709   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6710   float result;
6711
6712   arg1 = (Dali::Vector3 *)jarg1;
6713   {
6714     try {
6715       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6716     } catch (std::out_of_range& e) {
6717       {
6718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6719       };
6720     } catch (std::exception& e) {
6721       {
6722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6723       };
6724     } catch (Dali::DaliException e) {
6725       {
6726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6727       };
6728     } catch (...) {
6729       {
6730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6731       };
6732     }
6733   }
6734
6735   jresult = result;
6736   return jresult;
6737 }
6738
6739
6740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6741   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6742
6743   arg1 = (Dali::Vector3 *)jarg1;
6744   {
6745     try {
6746       (arg1)->Normalize();
6747     } catch (std::out_of_range& e) {
6748       {
6749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6750       };
6751     } catch (std::exception& e) {
6752       {
6753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6754       };
6755     } catch (Dali::DaliException e) {
6756       {
6757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6758       };
6759     } catch (...) {
6760       {
6761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6762       };
6763     }
6764   }
6765
6766 }
6767
6768
6769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6770   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6771   Dali::Vector3 *arg2 = 0 ;
6772   Dali::Vector3 *arg3 = 0 ;
6773
6774   arg1 = (Dali::Vector3 *)jarg1;
6775   arg2 = (Dali::Vector3 *)jarg2;
6776   if (!arg2) {
6777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6778     return ;
6779   }
6780   arg3 = (Dali::Vector3 *)jarg3;
6781   if (!arg3) {
6782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6783     return ;
6784   }
6785   {
6786     try {
6787       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6788     } catch (std::out_of_range& e) {
6789       {
6790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6791       };
6792     } catch (std::exception& e) {
6793       {
6794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6795       };
6796     } catch (Dali::DaliException e) {
6797       {
6798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6799       };
6800     } catch (...) {
6801       {
6802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6803       };
6804     }
6805   }
6806
6807 }
6808
6809
6810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6811   void * jresult ;
6812   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6813   float *result = 0 ;
6814
6815   arg1 = (Dali::Vector3 *)jarg1;
6816   {
6817     try {
6818       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6819     } catch (std::out_of_range& e) {
6820       {
6821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6822       };
6823     } catch (std::exception& e) {
6824       {
6825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6826       };
6827     } catch (Dali::DaliException e) {
6828       {
6829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6830       };
6831     } catch (...) {
6832       {
6833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6834       };
6835     }
6836   }
6837
6838   jresult = (void *)result;
6839   return jresult;
6840 }
6841
6842
6843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6844   void * jresult ;
6845   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6846   Dali::Vector2 *result = 0 ;
6847
6848   arg1 = (Dali::Vector3 *)jarg1;
6849   {
6850     try {
6851       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6852     } catch (std::out_of_range& e) {
6853       {
6854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6855       };
6856     } catch (std::exception& e) {
6857       {
6858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6859       };
6860     } catch (Dali::DaliException e) {
6861       {
6862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6863       };
6864     } catch (...) {
6865       {
6866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6867       };
6868     }
6869   }
6870
6871   jresult = (void *)result;
6872   return jresult;
6873 }
6874
6875
6876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6877   void * jresult ;
6878   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6879   Dali::Vector2 *result = 0 ;
6880
6881   arg1 = (Dali::Vector3 *)jarg1;
6882   {
6883     try {
6884       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6885     } catch (std::out_of_range& e) {
6886       {
6887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6888       };
6889     } catch (std::exception& e) {
6890       {
6891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6892       };
6893     } catch (Dali::DaliException e) {
6894       {
6895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6896       };
6897     } catch (...) {
6898       {
6899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6900       };
6901     }
6902   }
6903
6904   jresult = (void *)result;
6905   return jresult;
6906 }
6907
6908
6909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6910   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6911   float arg2 ;
6912
6913   arg1 = (Dali::Vector3 *)jarg1;
6914   arg2 = (float)jarg2;
6915   if (arg1) (arg1)->x = arg2;
6916 }
6917
6918
6919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6920   float jresult ;
6921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6922   float result;
6923
6924   arg1 = (Dali::Vector3 *)jarg1;
6925   result = (float) ((arg1)->x);
6926   jresult = result;
6927   return jresult;
6928 }
6929
6930
6931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6932   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6933   float arg2 ;
6934
6935   arg1 = (Dali::Vector3 *)jarg1;
6936   arg2 = (float)jarg2;
6937   if (arg1) (arg1)->width = arg2;
6938 }
6939
6940
6941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6942   float jresult ;
6943   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6944   float result;
6945
6946   arg1 = (Dali::Vector3 *)jarg1;
6947   result = (float) ((arg1)->width);
6948   jresult = result;
6949   return jresult;
6950 }
6951
6952
6953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6954   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6955   float arg2 ;
6956
6957   arg1 = (Dali::Vector3 *)jarg1;
6958   arg2 = (float)jarg2;
6959   if (arg1) (arg1)->r = arg2;
6960 }
6961
6962
6963 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6964   float jresult ;
6965   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6966   float result;
6967
6968   arg1 = (Dali::Vector3 *)jarg1;
6969   result = (float) ((arg1)->r);
6970   jresult = result;
6971   return jresult;
6972 }
6973
6974
6975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6976   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6977   float arg2 ;
6978
6979   arg1 = (Dali::Vector3 *)jarg1;
6980   arg2 = (float)jarg2;
6981   if (arg1) (arg1)->y = arg2;
6982 }
6983
6984
6985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6986   float jresult ;
6987   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6988   float result;
6989
6990   arg1 = (Dali::Vector3 *)jarg1;
6991   result = (float) ((arg1)->y);
6992   jresult = result;
6993   return jresult;
6994 }
6995
6996
6997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6998   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6999   float arg2 ;
7000
7001   arg1 = (Dali::Vector3 *)jarg1;
7002   arg2 = (float)jarg2;
7003   if (arg1) (arg1)->height = arg2;
7004 }
7005
7006
7007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7008   float jresult ;
7009   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7010   float result;
7011
7012   arg1 = (Dali::Vector3 *)jarg1;
7013   result = (float) ((arg1)->height);
7014   jresult = result;
7015   return jresult;
7016 }
7017
7018
7019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7020   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7021   float arg2 ;
7022
7023   arg1 = (Dali::Vector3 *)jarg1;
7024   arg2 = (float)jarg2;
7025   if (arg1) (arg1)->g = arg2;
7026 }
7027
7028
7029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7030   float jresult ;
7031   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7032   float result;
7033
7034   arg1 = (Dali::Vector3 *)jarg1;
7035   result = (float) ((arg1)->g);
7036   jresult = result;
7037   return jresult;
7038 }
7039
7040
7041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7042   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7043   float arg2 ;
7044
7045   arg1 = (Dali::Vector3 *)jarg1;
7046   arg2 = (float)jarg2;
7047   if (arg1) (arg1)->z = arg2;
7048 }
7049
7050
7051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7052   float jresult ;
7053   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7054   float result;
7055
7056   arg1 = (Dali::Vector3 *)jarg1;
7057   result = (float) ((arg1)->z);
7058   jresult = result;
7059   return jresult;
7060 }
7061
7062
7063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7064   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7065   float arg2 ;
7066
7067   arg1 = (Dali::Vector3 *)jarg1;
7068   arg2 = (float)jarg2;
7069   if (arg1) (arg1)->depth = arg2;
7070 }
7071
7072
7073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7074   float jresult ;
7075   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7076   float result;
7077
7078   arg1 = (Dali::Vector3 *)jarg1;
7079   result = (float) ((arg1)->depth);
7080   jresult = result;
7081   return jresult;
7082 }
7083
7084
7085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7086   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7087   float arg2 ;
7088
7089   arg1 = (Dali::Vector3 *)jarg1;
7090   arg2 = (float)jarg2;
7091   if (arg1) (arg1)->b = arg2;
7092 }
7093
7094
7095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7096   float jresult ;
7097   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7098   float result;
7099
7100   arg1 = (Dali::Vector3 *)jarg1;
7101   result = (float) ((arg1)->b);
7102   jresult = result;
7103   return jresult;
7104 }
7105
7106
7107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7108   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7109
7110   arg1 = (Dali::Vector3 *)jarg1;
7111   {
7112     try {
7113       delete arg1;
7114     } catch (std::out_of_range& e) {
7115       {
7116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7117       };
7118     } catch (std::exception& e) {
7119       {
7120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7121       };
7122     } catch (Dali::DaliException e) {
7123       {
7124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7125       };
7126     } catch (...) {
7127       {
7128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7129       };
7130     }
7131   }
7132
7133 }
7134
7135
7136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7137   void * jresult ;
7138   Dali::Vector3 *arg1 = 0 ;
7139   Dali::Vector3 *arg2 = 0 ;
7140   Dali::Vector3 result;
7141
7142   arg1 = (Dali::Vector3 *)jarg1;
7143   if (!arg1) {
7144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7145     return 0;
7146   }
7147   arg2 = (Dali::Vector3 *)jarg2;
7148   if (!arg2) {
7149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7150     return 0;
7151   }
7152   {
7153     try {
7154       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7155     } catch (std::out_of_range& e) {
7156       {
7157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7158       };
7159     } catch (std::exception& e) {
7160       {
7161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7162       };
7163     } catch (Dali::DaliException e) {
7164       {
7165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7166       };
7167     } catch (...) {
7168       {
7169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7170       };
7171     }
7172   }
7173
7174   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7175   return jresult;
7176 }
7177
7178
7179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7180   void * jresult ;
7181   Dali::Vector3 *arg1 = 0 ;
7182   Dali::Vector3 *arg2 = 0 ;
7183   Dali::Vector3 result;
7184
7185   arg1 = (Dali::Vector3 *)jarg1;
7186   if (!arg1) {
7187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7188     return 0;
7189   }
7190   arg2 = (Dali::Vector3 *)jarg2;
7191   if (!arg2) {
7192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7193     return 0;
7194   }
7195   {
7196     try {
7197       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7198     } catch (std::out_of_range& e) {
7199       {
7200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7201       };
7202     } catch (std::exception& e) {
7203       {
7204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7205       };
7206     } catch (Dali::DaliException e) {
7207       {
7208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7209       };
7210     } catch (...) {
7211       {
7212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7213       };
7214     }
7215   }
7216
7217   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7218   return jresult;
7219 }
7220
7221
7222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7223   void * jresult ;
7224   Dali::Vector3 *arg1 = 0 ;
7225   float *arg2 = 0 ;
7226   float *arg3 = 0 ;
7227   float temp2 ;
7228   float temp3 ;
7229   Dali::Vector3 result;
7230
7231   arg1 = (Dali::Vector3 *)jarg1;
7232   if (!arg1) {
7233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7234     return 0;
7235   }
7236   temp2 = (float)jarg2;
7237   arg2 = &temp2;
7238   temp3 = (float)jarg3;
7239   arg3 = &temp3;
7240   {
7241     try {
7242       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7243     } catch (std::out_of_range& e) {
7244       {
7245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7246       };
7247     } catch (std::exception& e) {
7248       {
7249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7250       };
7251     } catch (Dali::DaliException e) {
7252       {
7253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7254       };
7255     } catch (...) {
7256       {
7257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7258       };
7259     }
7260   }
7261
7262   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7263   return jresult;
7264 }
7265
7266
7267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7268   void * jresult ;
7269   Dali::Vector4 *result = 0 ;
7270
7271   {
7272     try {
7273       result = (Dali::Vector4 *)new Dali::Vector4();
7274     } catch (std::out_of_range& e) {
7275       {
7276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7277       };
7278     } catch (std::exception& e) {
7279       {
7280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7281       };
7282     } catch (Dali::DaliException e) {
7283       {
7284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7285       };
7286     } catch (...) {
7287       {
7288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7289       };
7290     }
7291   }
7292
7293   jresult = (void *)result;
7294   return jresult;
7295 }
7296
7297
7298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7299   void * jresult ;
7300   float arg1 ;
7301   float arg2 ;
7302   float arg3 ;
7303   float arg4 ;
7304   Dali::Vector4 *result = 0 ;
7305
7306   arg1 = (float)jarg1;
7307   arg2 = (float)jarg2;
7308   arg3 = (float)jarg3;
7309   arg4 = (float)jarg4;
7310   {
7311     try {
7312       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7313     } catch (std::out_of_range& e) {
7314       {
7315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7316       };
7317     } catch (std::exception& e) {
7318       {
7319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7320       };
7321     } catch (Dali::DaliException e) {
7322       {
7323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7324       };
7325     } catch (...) {
7326       {
7327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7328       };
7329     }
7330   }
7331
7332   jresult = (void *)result;
7333   return jresult;
7334 }
7335
7336
7337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7338   void * jresult ;
7339   float *arg1 = (float *) 0 ;
7340   Dali::Vector4 *result = 0 ;
7341
7342   arg1 = jarg1;
7343   {
7344     try {
7345       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7346     } catch (std::out_of_range& e) {
7347       {
7348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7349       };
7350     } catch (std::exception& e) {
7351       {
7352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7353       };
7354     } catch (Dali::DaliException e) {
7355       {
7356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7357       };
7358     } catch (...) {
7359       {
7360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7361       };
7362     }
7363   }
7364
7365   jresult = (void *)result;
7366
7367
7368   return jresult;
7369 }
7370
7371
7372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7373   void * jresult ;
7374   Dali::Vector2 *arg1 = 0 ;
7375   Dali::Vector4 *result = 0 ;
7376
7377   arg1 = (Dali::Vector2 *)jarg1;
7378   if (!arg1) {
7379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7380     return 0;
7381   }
7382   {
7383     try {
7384       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7385     } catch (std::out_of_range& e) {
7386       {
7387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7388       };
7389     } catch (std::exception& e) {
7390       {
7391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7392       };
7393     } catch (Dali::DaliException e) {
7394       {
7395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7396       };
7397     } catch (...) {
7398       {
7399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7400       };
7401     }
7402   }
7403
7404   jresult = (void *)result;
7405   return jresult;
7406 }
7407
7408
7409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7410   void * jresult ;
7411   Dali::Vector3 *arg1 = 0 ;
7412   Dali::Vector4 *result = 0 ;
7413
7414   arg1 = (Dali::Vector3 *)jarg1;
7415   if (!arg1) {
7416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7417     return 0;
7418   }
7419   {
7420     try {
7421       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7422     } catch (std::out_of_range& e) {
7423       {
7424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7425       };
7426     } catch (std::exception& e) {
7427       {
7428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7429       };
7430     } catch (Dali::DaliException e) {
7431       {
7432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7433       };
7434     } catch (...) {
7435       {
7436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7437       };
7438     }
7439   }
7440
7441   jresult = (void *)result;
7442   return jresult;
7443 }
7444
7445
7446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7447   void * jresult ;
7448   Dali::Vector4 *result = 0 ;
7449
7450   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7451   jresult = (void *)result;
7452   return jresult;
7453 }
7454
7455
7456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7457   void * jresult ;
7458   Dali::Vector4 *result = 0 ;
7459
7460   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7461   jresult = (void *)result;
7462   return jresult;
7463 }
7464
7465
7466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7467   void * jresult ;
7468   Dali::Vector4 *result = 0 ;
7469
7470   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7471   jresult = (void *)result;
7472   return jresult;
7473 }
7474
7475
7476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7477   void * jresult ;
7478   Dali::Vector4 *result = 0 ;
7479
7480   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7481   jresult = (void *)result;
7482   return jresult;
7483 }
7484
7485
7486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7487   void * jresult ;
7488   Dali::Vector4 *result = 0 ;
7489
7490   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7491   jresult = (void *)result;
7492   return jresult;
7493 }
7494
7495
7496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7497   void * jresult ;
7498   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7499   float *arg2 = (float *) 0 ;
7500   Dali::Vector4 *result = 0 ;
7501
7502   arg1 = (Dali::Vector4 *)jarg1;
7503   arg2 = jarg2;
7504   {
7505     try {
7506       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7507     } catch (std::out_of_range& e) {
7508       {
7509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7510       };
7511     } catch (std::exception& e) {
7512       {
7513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7514       };
7515     } catch (Dali::DaliException e) {
7516       {
7517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7518       };
7519     } catch (...) {
7520       {
7521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7522       };
7523     }
7524   }
7525
7526   jresult = (void *)result;
7527
7528
7529   return jresult;
7530 }
7531
7532
7533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7534   void * jresult ;
7535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7536   Dali::Vector2 *arg2 = 0 ;
7537   Dali::Vector4 *result = 0 ;
7538
7539   arg1 = (Dali::Vector4 *)jarg1;
7540   arg2 = (Dali::Vector2 *)jarg2;
7541   if (!arg2) {
7542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7543     return 0;
7544   }
7545   {
7546     try {
7547       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7548     } catch (std::out_of_range& e) {
7549       {
7550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7551       };
7552     } catch (std::exception& e) {
7553       {
7554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7555       };
7556     } catch (Dali::DaliException e) {
7557       {
7558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7559       };
7560     } catch (...) {
7561       {
7562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7563       };
7564     }
7565   }
7566
7567   jresult = (void *)result;
7568   return jresult;
7569 }
7570
7571
7572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7573   void * jresult ;
7574   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7575   Dali::Vector3 *arg2 = 0 ;
7576   Dali::Vector4 *result = 0 ;
7577
7578   arg1 = (Dali::Vector4 *)jarg1;
7579   arg2 = (Dali::Vector3 *)jarg2;
7580   if (!arg2) {
7581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7582     return 0;
7583   }
7584   {
7585     try {
7586       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7587     } catch (std::out_of_range& e) {
7588       {
7589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7590       };
7591     } catch (std::exception& e) {
7592       {
7593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7594       };
7595     } catch (Dali::DaliException e) {
7596       {
7597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7598       };
7599     } catch (...) {
7600       {
7601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7602       };
7603     }
7604   }
7605
7606   jresult = (void *)result;
7607   return jresult;
7608 }
7609
7610
7611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7612   void * jresult ;
7613   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7614   Dali::Vector4 *arg2 = 0 ;
7615   Dali::Vector4 result;
7616
7617   arg1 = (Dali::Vector4 *)jarg1;
7618   arg2 = (Dali::Vector4 *)jarg2;
7619   if (!arg2) {
7620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7621     return 0;
7622   }
7623   {
7624     try {
7625       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7626     } catch (std::out_of_range& e) {
7627       {
7628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7629       };
7630     } catch (std::exception& e) {
7631       {
7632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7633       };
7634     } catch (Dali::DaliException e) {
7635       {
7636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7637       };
7638     } catch (...) {
7639       {
7640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7641       };
7642     }
7643   }
7644
7645   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7646   return jresult;
7647 }
7648
7649
7650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7651   void * jresult ;
7652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7653   Dali::Vector4 *arg2 = 0 ;
7654   Dali::Vector4 *result = 0 ;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   arg2 = (Dali::Vector4 *)jarg2;
7658   if (!arg2) {
7659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7660     return 0;
7661   }
7662   {
7663     try {
7664       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7665     } catch (std::out_of_range& e) {
7666       {
7667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7668       };
7669     } catch (std::exception& e) {
7670       {
7671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7672       };
7673     } catch (Dali::DaliException e) {
7674       {
7675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7676       };
7677     } catch (...) {
7678       {
7679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7680       };
7681     }
7682   }
7683
7684   jresult = (void *)result;
7685   return jresult;
7686 }
7687
7688
7689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7690   void * jresult ;
7691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7692   Dali::Vector4 *arg2 = 0 ;
7693   Dali::Vector4 result;
7694
7695   arg1 = (Dali::Vector4 *)jarg1;
7696   arg2 = (Dali::Vector4 *)jarg2;
7697   if (!arg2) {
7698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7699     return 0;
7700   }
7701   {
7702     try {
7703       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7704     } catch (std::out_of_range& e) {
7705       {
7706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7707       };
7708     } catch (std::exception& e) {
7709       {
7710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7711       };
7712     } catch (Dali::DaliException e) {
7713       {
7714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7715       };
7716     } catch (...) {
7717       {
7718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7719       };
7720     }
7721   }
7722
7723   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7724   return jresult;
7725 }
7726
7727
7728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7729   void * jresult ;
7730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7731   Dali::Vector4 *arg2 = 0 ;
7732   Dali::Vector4 *result = 0 ;
7733
7734   arg1 = (Dali::Vector4 *)jarg1;
7735   arg2 = (Dali::Vector4 *)jarg2;
7736   if (!arg2) {
7737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7738     return 0;
7739   }
7740   {
7741     try {
7742       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7743     } catch (std::out_of_range& e) {
7744       {
7745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7746       };
7747     } catch (std::exception& e) {
7748       {
7749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7750       };
7751     } catch (Dali::DaliException e) {
7752       {
7753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7754       };
7755     } catch (...) {
7756       {
7757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7758       };
7759     }
7760   }
7761
7762   jresult = (void *)result;
7763   return jresult;
7764 }
7765
7766
7767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7768   void * jresult ;
7769   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7770   Dali::Vector4 *arg2 = 0 ;
7771   Dali::Vector4 result;
7772
7773   arg1 = (Dali::Vector4 *)jarg1;
7774   arg2 = (Dali::Vector4 *)jarg2;
7775   if (!arg2) {
7776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7777     return 0;
7778   }
7779   {
7780     try {
7781       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7782     } catch (std::out_of_range& e) {
7783       {
7784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7785       };
7786     } catch (std::exception& e) {
7787       {
7788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7789       };
7790     } catch (Dali::DaliException e) {
7791       {
7792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7793       };
7794     } catch (...) {
7795       {
7796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7797       };
7798     }
7799   }
7800
7801   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7802   return jresult;
7803 }
7804
7805
7806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7807   void * jresult ;
7808   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7809   float arg2 ;
7810   Dali::Vector4 result;
7811
7812   arg1 = (Dali::Vector4 *)jarg1;
7813   arg2 = (float)jarg2;
7814   {
7815     try {
7816       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7817     } catch (std::out_of_range& e) {
7818       {
7819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7820       };
7821     } catch (std::exception& e) {
7822       {
7823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7824       };
7825     } catch (Dali::DaliException e) {
7826       {
7827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7828       };
7829     } catch (...) {
7830       {
7831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7832       };
7833     }
7834   }
7835
7836   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7837   return jresult;
7838 }
7839
7840
7841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7842   void * jresult ;
7843   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7844   Dali::Vector4 *arg2 = 0 ;
7845   Dali::Vector4 *result = 0 ;
7846
7847   arg1 = (Dali::Vector4 *)jarg1;
7848   arg2 = (Dali::Vector4 *)jarg2;
7849   if (!arg2) {
7850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7851     return 0;
7852   }
7853   {
7854     try {
7855       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7856     } catch (std::out_of_range& e) {
7857       {
7858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7859       };
7860     } catch (std::exception& e) {
7861       {
7862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7863       };
7864     } catch (Dali::DaliException e) {
7865       {
7866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7867       };
7868     } catch (...) {
7869       {
7870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7871       };
7872     }
7873   }
7874
7875   jresult = (void *)result;
7876   return jresult;
7877 }
7878
7879
7880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7881   void * jresult ;
7882   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7883   float arg2 ;
7884   Dali::Vector4 *result = 0 ;
7885
7886   arg1 = (Dali::Vector4 *)jarg1;
7887   arg2 = (float)jarg2;
7888   {
7889     try {
7890       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7891     } catch (std::out_of_range& e) {
7892       {
7893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7894       };
7895     } catch (std::exception& e) {
7896       {
7897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7898       };
7899     } catch (Dali::DaliException e) {
7900       {
7901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7902       };
7903     } catch (...) {
7904       {
7905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7906       };
7907     }
7908   }
7909
7910   jresult = (void *)result;
7911   return jresult;
7912 }
7913
7914
7915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7916   void * jresult ;
7917   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7918   Dali::Vector4 *arg2 = 0 ;
7919   Dali::Vector4 result;
7920
7921   arg1 = (Dali::Vector4 *)jarg1;
7922   arg2 = (Dali::Vector4 *)jarg2;
7923   if (!arg2) {
7924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7925     return 0;
7926   }
7927   {
7928     try {
7929       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7930     } catch (std::out_of_range& e) {
7931       {
7932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7933       };
7934     } catch (std::exception& e) {
7935       {
7936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7937       };
7938     } catch (Dali::DaliException e) {
7939       {
7940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7941       };
7942     } catch (...) {
7943       {
7944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7945       };
7946     }
7947   }
7948
7949   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7950   return jresult;
7951 }
7952
7953
7954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7955   void * jresult ;
7956   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7957   float arg2 ;
7958   Dali::Vector4 result;
7959
7960   arg1 = (Dali::Vector4 *)jarg1;
7961   arg2 = (float)jarg2;
7962   {
7963     try {
7964       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7965     } catch (std::out_of_range& e) {
7966       {
7967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7968       };
7969     } catch (std::exception& e) {
7970       {
7971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7972       };
7973     } catch (Dali::DaliException e) {
7974       {
7975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7976       };
7977     } catch (...) {
7978       {
7979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7980       };
7981     }
7982   }
7983
7984   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7985   return jresult;
7986 }
7987
7988
7989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7990   void * jresult ;
7991   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7992   Dali::Vector4 *arg2 = 0 ;
7993   Dali::Vector4 *result = 0 ;
7994
7995   arg1 = (Dali::Vector4 *)jarg1;
7996   arg2 = (Dali::Vector4 *)jarg2;
7997   if (!arg2) {
7998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7999     return 0;
8000   }
8001   {
8002     try {
8003       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8004     } catch (std::out_of_range& e) {
8005       {
8006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8007       };
8008     } catch (std::exception& e) {
8009       {
8010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8011       };
8012     } catch (Dali::DaliException e) {
8013       {
8014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8015       };
8016     } catch (...) {
8017       {
8018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8019       };
8020     }
8021   }
8022
8023   jresult = (void *)result;
8024   return jresult;
8025 }
8026
8027
8028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8029   void * jresult ;
8030   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8031   float arg2 ;
8032   Dali::Vector4 *result = 0 ;
8033
8034   arg1 = (Dali::Vector4 *)jarg1;
8035   arg2 = (float)jarg2;
8036   {
8037     try {
8038       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8039     } catch (std::out_of_range& e) {
8040       {
8041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8042       };
8043     } catch (std::exception& e) {
8044       {
8045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8046       };
8047     } catch (Dali::DaliException e) {
8048       {
8049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8050       };
8051     } catch (...) {
8052       {
8053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8054       };
8055     }
8056   }
8057
8058   jresult = (void *)result;
8059   return jresult;
8060 }
8061
8062
8063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8064   void * jresult ;
8065   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8066   Dali::Vector4 result;
8067
8068   arg1 = (Dali::Vector4 *)jarg1;
8069   {
8070     try {
8071       result = ((Dali::Vector4 const *)arg1)->operator -();
8072     } catch (std::out_of_range& e) {
8073       {
8074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8075       };
8076     } catch (std::exception& e) {
8077       {
8078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8079       };
8080     } catch (Dali::DaliException e) {
8081       {
8082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8083       };
8084     } catch (...) {
8085       {
8086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8087       };
8088     }
8089   }
8090
8091   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8092   return jresult;
8093 }
8094
8095
8096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8097   unsigned int jresult ;
8098   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8099   Dali::Vector4 *arg2 = 0 ;
8100   bool result;
8101
8102   arg1 = (Dali::Vector4 *)jarg1;
8103   arg2 = (Dali::Vector4 *)jarg2;
8104   if (!arg2) {
8105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8106     return 0;
8107   }
8108   {
8109     try {
8110       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8111     } catch (std::out_of_range& e) {
8112       {
8113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8114       };
8115     } catch (std::exception& e) {
8116       {
8117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8118       };
8119     } catch (Dali::DaliException e) {
8120       {
8121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8122       };
8123     } catch (...) {
8124       {
8125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8126       };
8127     }
8128   }
8129
8130   jresult = result;
8131   return jresult;
8132 }
8133
8134
8135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8136   unsigned int jresult ;
8137   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8138   Dali::Vector4 *arg2 = 0 ;
8139   bool result;
8140
8141   arg1 = (Dali::Vector4 *)jarg1;
8142   arg2 = (Dali::Vector4 *)jarg2;
8143   if (!arg2) {
8144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8145     return 0;
8146   }
8147   {
8148     try {
8149       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8150     } catch (std::out_of_range& e) {
8151       {
8152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8153       };
8154     } catch (std::exception& e) {
8155       {
8156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8157       };
8158     } catch (Dali::DaliException e) {
8159       {
8160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8161       };
8162     } catch (...) {
8163       {
8164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8165       };
8166     }
8167   }
8168
8169   jresult = result;
8170   return jresult;
8171 }
8172
8173
8174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8175   float jresult ;
8176   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8177   unsigned int arg2 ;
8178   float *result = 0 ;
8179
8180   arg1 = (Dali::Vector4 *)jarg1;
8181   arg2 = (unsigned int)jarg2;
8182   {
8183     try {
8184       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8185     } catch (std::out_of_range& e) {
8186       {
8187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8188       };
8189     } catch (std::exception& e) {
8190       {
8191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8192       };
8193     } catch (Dali::DaliException e) {
8194       {
8195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8196       };
8197     } catch (...) {
8198       {
8199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8200       };
8201     }
8202   }
8203
8204   jresult = *result;
8205   return jresult;
8206 }
8207
8208
8209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8210   float jresult ;
8211   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8212   Dali::Vector3 *arg2 = 0 ;
8213   float result;
8214
8215   arg1 = (Dali::Vector4 *)jarg1;
8216   arg2 = (Dali::Vector3 *)jarg2;
8217   if (!arg2) {
8218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8219     return 0;
8220   }
8221   {
8222     try {
8223       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8224     } catch (std::out_of_range& e) {
8225       {
8226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8227       };
8228     } catch (std::exception& e) {
8229       {
8230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8231       };
8232     } catch (Dali::DaliException e) {
8233       {
8234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8235       };
8236     } catch (...) {
8237       {
8238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8239       };
8240     }
8241   }
8242
8243   jresult = result;
8244   return jresult;
8245 }
8246
8247
8248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8249   float jresult ;
8250   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8251   Dali::Vector4 *arg2 = 0 ;
8252   float result;
8253
8254   arg1 = (Dali::Vector4 *)jarg1;
8255   arg2 = (Dali::Vector4 *)jarg2;
8256   if (!arg2) {
8257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8258     return 0;
8259   }
8260   {
8261     try {
8262       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8263     } catch (std::out_of_range& e) {
8264       {
8265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8266       };
8267     } catch (std::exception& e) {
8268       {
8269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8270       };
8271     } catch (Dali::DaliException e) {
8272       {
8273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8274       };
8275     } catch (...) {
8276       {
8277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8278       };
8279     }
8280   }
8281
8282   jresult = result;
8283   return jresult;
8284 }
8285
8286
8287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8288   float jresult ;
8289   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8290   Dali::Vector4 *arg2 = 0 ;
8291   float result;
8292
8293   arg1 = (Dali::Vector4 *)jarg1;
8294   arg2 = (Dali::Vector4 *)jarg2;
8295   if (!arg2) {
8296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8297     return 0;
8298   }
8299   {
8300     try {
8301       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8302     } catch (std::out_of_range& e) {
8303       {
8304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8305       };
8306     } catch (std::exception& e) {
8307       {
8308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8309       };
8310     } catch (Dali::DaliException e) {
8311       {
8312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8313       };
8314     } catch (...) {
8315       {
8316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8317       };
8318     }
8319   }
8320
8321   jresult = result;
8322   return jresult;
8323 }
8324
8325
8326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8327   void * jresult ;
8328   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8329   Dali::Vector4 *arg2 = 0 ;
8330   Dali::Vector4 result;
8331
8332   arg1 = (Dali::Vector4 *)jarg1;
8333   arg2 = (Dali::Vector4 *)jarg2;
8334   if (!arg2) {
8335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8336     return 0;
8337   }
8338   {
8339     try {
8340       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8341     } catch (std::out_of_range& e) {
8342       {
8343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8344       };
8345     } catch (std::exception& e) {
8346       {
8347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8348       };
8349     } catch (Dali::DaliException e) {
8350       {
8351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8352       };
8353     } catch (...) {
8354       {
8355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8356       };
8357     }
8358   }
8359
8360   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8361   return jresult;
8362 }
8363
8364
8365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8366   float jresult ;
8367   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8368   float result;
8369
8370   arg1 = (Dali::Vector4 *)jarg1;
8371   {
8372     try {
8373       result = (float)((Dali::Vector4 const *)arg1)->Length();
8374     } catch (std::out_of_range& e) {
8375       {
8376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8377       };
8378     } catch (std::exception& e) {
8379       {
8380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8381       };
8382     } catch (Dali::DaliException e) {
8383       {
8384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8385       };
8386     } catch (...) {
8387       {
8388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8389       };
8390     }
8391   }
8392
8393   jresult = result;
8394   return jresult;
8395 }
8396
8397
8398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8399   float jresult ;
8400   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8401   float result;
8402
8403   arg1 = (Dali::Vector4 *)jarg1;
8404   {
8405     try {
8406       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8407     } catch (std::out_of_range& e) {
8408       {
8409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8410       };
8411     } catch (std::exception& e) {
8412       {
8413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8414       };
8415     } catch (Dali::DaliException e) {
8416       {
8417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8418       };
8419     } catch (...) {
8420       {
8421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8422       };
8423     }
8424   }
8425
8426   jresult = result;
8427   return jresult;
8428 }
8429
8430
8431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8432   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8433
8434   arg1 = (Dali::Vector4 *)jarg1;
8435   {
8436     try {
8437       (arg1)->Normalize();
8438     } catch (std::out_of_range& e) {
8439       {
8440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8441       };
8442     } catch (std::exception& e) {
8443       {
8444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8445       };
8446     } catch (Dali::DaliException e) {
8447       {
8448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8449       };
8450     } catch (...) {
8451       {
8452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8453       };
8454     }
8455   }
8456
8457 }
8458
8459
8460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8461   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8462   Dali::Vector4 *arg2 = 0 ;
8463   Dali::Vector4 *arg3 = 0 ;
8464
8465   arg1 = (Dali::Vector4 *)jarg1;
8466   arg2 = (Dali::Vector4 *)jarg2;
8467   if (!arg2) {
8468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8469     return ;
8470   }
8471   arg3 = (Dali::Vector4 *)jarg3;
8472   if (!arg3) {
8473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8474     return ;
8475   }
8476   {
8477     try {
8478       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8479     } catch (std::out_of_range& e) {
8480       {
8481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8482       };
8483     } catch (std::exception& e) {
8484       {
8485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8486       };
8487     } catch (Dali::DaliException e) {
8488       {
8489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8490       };
8491     } catch (...) {
8492       {
8493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8494       };
8495     }
8496   }
8497
8498 }
8499
8500
8501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8502   void * jresult ;
8503   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8504   float *result = 0 ;
8505
8506   arg1 = (Dali::Vector4 *)jarg1;
8507   {
8508     try {
8509       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8510     } catch (std::out_of_range& e) {
8511       {
8512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8513       };
8514     } catch (std::exception& e) {
8515       {
8516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8517       };
8518     } catch (Dali::DaliException e) {
8519       {
8520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8521       };
8522     } catch (...) {
8523       {
8524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8525       };
8526     }
8527   }
8528
8529   jresult = (void *)result;
8530   return jresult;
8531 }
8532
8533
8534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8536   float arg2 ;
8537
8538   arg1 = (Dali::Vector4 *)jarg1;
8539   arg2 = (float)jarg2;
8540   if (arg1) (arg1)->x = arg2;
8541 }
8542
8543
8544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8545   float jresult ;
8546   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8547   float result;
8548
8549   arg1 = (Dali::Vector4 *)jarg1;
8550   result = (float) ((arg1)->x);
8551   jresult = result;
8552   return jresult;
8553 }
8554
8555
8556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8557   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8558   float arg2 ;
8559
8560   arg1 = (Dali::Vector4 *)jarg1;
8561   arg2 = (float)jarg2;
8562   if (arg1) (arg1)->r = arg2;
8563 }
8564
8565
8566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8567   float jresult ;
8568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8569   float result;
8570
8571   arg1 = (Dali::Vector4 *)jarg1;
8572   result = (float) ((arg1)->r);
8573   jresult = result;
8574   return jresult;
8575 }
8576
8577
8578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8579   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8580   float arg2 ;
8581
8582   arg1 = (Dali::Vector4 *)jarg1;
8583   arg2 = (float)jarg2;
8584   if (arg1) (arg1)->s = arg2;
8585 }
8586
8587
8588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8589   float jresult ;
8590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8591   float result;
8592
8593   arg1 = (Dali::Vector4 *)jarg1;
8594   result = (float) ((arg1)->s);
8595   jresult = result;
8596   return jresult;
8597 }
8598
8599
8600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8601   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8602   float arg2 ;
8603
8604   arg1 = (Dali::Vector4 *)jarg1;
8605   arg2 = (float)jarg2;
8606   if (arg1) (arg1)->y = arg2;
8607 }
8608
8609
8610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8611   float jresult ;
8612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8613   float result;
8614
8615   arg1 = (Dali::Vector4 *)jarg1;
8616   result = (float) ((arg1)->y);
8617   jresult = result;
8618   return jresult;
8619 }
8620
8621
8622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8623   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8624   float arg2 ;
8625
8626   arg1 = (Dali::Vector4 *)jarg1;
8627   arg2 = (float)jarg2;
8628   if (arg1) (arg1)->g = arg2;
8629 }
8630
8631
8632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8633   float jresult ;
8634   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8635   float result;
8636
8637   arg1 = (Dali::Vector4 *)jarg1;
8638   result = (float) ((arg1)->g);
8639   jresult = result;
8640   return jresult;
8641 }
8642
8643
8644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8645   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8646   float arg2 ;
8647
8648   arg1 = (Dali::Vector4 *)jarg1;
8649   arg2 = (float)jarg2;
8650   if (arg1) (arg1)->t = arg2;
8651 }
8652
8653
8654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8655   float jresult ;
8656   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8657   float result;
8658
8659   arg1 = (Dali::Vector4 *)jarg1;
8660   result = (float) ((arg1)->t);
8661   jresult = result;
8662   return jresult;
8663 }
8664
8665
8666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8668   float arg2 ;
8669
8670   arg1 = (Dali::Vector4 *)jarg1;
8671   arg2 = (float)jarg2;
8672   if (arg1) (arg1)->z = arg2;
8673 }
8674
8675
8676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8677   float jresult ;
8678   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8679   float result;
8680
8681   arg1 = (Dali::Vector4 *)jarg1;
8682   result = (float) ((arg1)->z);
8683   jresult = result;
8684   return jresult;
8685 }
8686
8687
8688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8690   float arg2 ;
8691
8692   arg1 = (Dali::Vector4 *)jarg1;
8693   arg2 = (float)jarg2;
8694   if (arg1) (arg1)->b = arg2;
8695 }
8696
8697
8698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8699   float jresult ;
8700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8701   float result;
8702
8703   arg1 = (Dali::Vector4 *)jarg1;
8704   result = (float) ((arg1)->b);
8705   jresult = result;
8706   return jresult;
8707 }
8708
8709
8710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8711   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8712   float arg2 ;
8713
8714   arg1 = (Dali::Vector4 *)jarg1;
8715   arg2 = (float)jarg2;
8716   if (arg1) (arg1)->p = arg2;
8717 }
8718
8719
8720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8721   float jresult ;
8722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8723   float result;
8724
8725   arg1 = (Dali::Vector4 *)jarg1;
8726   result = (float) ((arg1)->p);
8727   jresult = result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8734   float arg2 ;
8735
8736   arg1 = (Dali::Vector4 *)jarg1;
8737   arg2 = (float)jarg2;
8738   if (arg1) (arg1)->w = arg2;
8739 }
8740
8741
8742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8743   float jresult ;
8744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8745   float result;
8746
8747   arg1 = (Dali::Vector4 *)jarg1;
8748   result = (float) ((arg1)->w);
8749   jresult = result;
8750   return jresult;
8751 }
8752
8753
8754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8756   float arg2 ;
8757
8758   arg1 = (Dali::Vector4 *)jarg1;
8759   arg2 = (float)jarg2;
8760   if (arg1) (arg1)->a = arg2;
8761 }
8762
8763
8764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8765   float jresult ;
8766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8767   float result;
8768
8769   arg1 = (Dali::Vector4 *)jarg1;
8770   result = (float) ((arg1)->a);
8771   jresult = result;
8772   return jresult;
8773 }
8774
8775
8776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8778   float arg2 ;
8779
8780   arg1 = (Dali::Vector4 *)jarg1;
8781   arg2 = (float)jarg2;
8782   if (arg1) (arg1)->q = arg2;
8783 }
8784
8785
8786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8787   float jresult ;
8788   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8789   float result;
8790
8791   arg1 = (Dali::Vector4 *)jarg1;
8792   result = (float) ((arg1)->q);
8793   jresult = result;
8794   return jresult;
8795 }
8796
8797
8798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8799   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8800
8801   arg1 = (Dali::Vector4 *)jarg1;
8802   {
8803     try {
8804       delete arg1;
8805     } catch (std::out_of_range& e) {
8806       {
8807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8808       };
8809     } catch (std::exception& e) {
8810       {
8811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8812       };
8813     } catch (Dali::DaliException e) {
8814       {
8815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8816       };
8817     } catch (...) {
8818       {
8819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8820       };
8821     }
8822   }
8823
8824 }
8825
8826
8827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8828   void * jresult ;
8829   Dali::Vector4 *arg1 = 0 ;
8830   Dali::Vector4 *arg2 = 0 ;
8831   Dali::Vector4 result;
8832
8833   arg1 = (Dali::Vector4 *)jarg1;
8834   if (!arg1) {
8835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8836     return 0;
8837   }
8838   arg2 = (Dali::Vector4 *)jarg2;
8839   if (!arg2) {
8840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8841     return 0;
8842   }
8843   {
8844     try {
8845       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8846     } catch (std::out_of_range& e) {
8847       {
8848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8849       };
8850     } catch (std::exception& e) {
8851       {
8852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8853       };
8854     } catch (Dali::DaliException e) {
8855       {
8856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8857       };
8858     } catch (...) {
8859       {
8860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8861       };
8862     }
8863   }
8864
8865   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8866   return jresult;
8867 }
8868
8869
8870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8871   void * jresult ;
8872   Dali::Vector4 *arg1 = 0 ;
8873   Dali::Vector4 *arg2 = 0 ;
8874   Dali::Vector4 result;
8875
8876   arg1 = (Dali::Vector4 *)jarg1;
8877   if (!arg1) {
8878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8879     return 0;
8880   }
8881   arg2 = (Dali::Vector4 *)jarg2;
8882   if (!arg2) {
8883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8884     return 0;
8885   }
8886   {
8887     try {
8888       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8889     } catch (std::out_of_range& e) {
8890       {
8891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8892       };
8893     } catch (std::exception& e) {
8894       {
8895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8896       };
8897     } catch (Dali::DaliException e) {
8898       {
8899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8900       };
8901     } catch (...) {
8902       {
8903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8904       };
8905     }
8906   }
8907
8908   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8909   return jresult;
8910 }
8911
8912
8913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8914   void * jresult ;
8915   Dali::Vector4 *arg1 = 0 ;
8916   float *arg2 = 0 ;
8917   float *arg3 = 0 ;
8918   float temp2 ;
8919   float temp3 ;
8920   Dali::Vector4 result;
8921
8922   arg1 = (Dali::Vector4 *)jarg1;
8923   if (!arg1) {
8924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8925     return 0;
8926   }
8927   temp2 = (float)jarg2;
8928   arg2 = &temp2;
8929   temp3 = (float)jarg3;
8930   arg3 = &temp3;
8931   {
8932     try {
8933       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8934     } catch (std::out_of_range& e) {
8935       {
8936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (std::exception& e) {
8939       {
8940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8941       };
8942     } catch (Dali::DaliException e) {
8943       {
8944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8945       };
8946     } catch (...) {
8947       {
8948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8949       };
8950     }
8951   }
8952
8953   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8954   return jresult;
8955 }
8956
8957
8958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8959   void * jresult ;
8960   Dali::Uint16Pair *result = 0 ;
8961
8962   {
8963     try {
8964       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8965     } catch (std::out_of_range& e) {
8966       {
8967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8968       };
8969     } catch (std::exception& e) {
8970       {
8971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8972       };
8973     } catch (Dali::DaliException e) {
8974       {
8975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8976       };
8977     } catch (...) {
8978       {
8979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8980       };
8981     }
8982   }
8983
8984   jresult = (void *)result;
8985   return jresult;
8986 }
8987
8988
8989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8990   void * jresult ;
8991   uint32_t arg1 ;
8992   uint32_t arg2 ;
8993   Dali::Uint16Pair *result = 0 ;
8994
8995   arg1 = (uint32_t)jarg1;
8996   arg2 = (uint32_t)jarg2;
8997   {
8998     try {
8999       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9000     } catch (std::out_of_range& e) {
9001       {
9002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9003       };
9004     } catch (std::exception& e) {
9005       {
9006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9007       };
9008     } catch (Dali::DaliException e) {
9009       {
9010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9011       };
9012     } catch (...) {
9013       {
9014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9015       };
9016     }
9017   }
9018
9019   jresult = (void *)result;
9020   return jresult;
9021 }
9022
9023
9024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9025   void * jresult ;
9026   Dali::Uint16Pair *arg1 = 0 ;
9027   Dali::Uint16Pair *result = 0 ;
9028
9029   arg1 = (Dali::Uint16Pair *)jarg1;
9030   if (!arg1) {
9031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9032     return 0;
9033   }
9034   {
9035     try {
9036       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9037     } catch (std::out_of_range& e) {
9038       {
9039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9040       };
9041     } catch (std::exception& e) {
9042       {
9043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9044       };
9045     } catch (Dali::DaliException e) {
9046       {
9047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9048       };
9049     } catch (...) {
9050       {
9051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9052       };
9053     }
9054   }
9055
9056   jresult = (void *)result;
9057   return jresult;
9058 }
9059
9060
9061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9062   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9063   uint16_t arg2 ;
9064
9065   arg1 = (Dali::Uint16Pair *)jarg1;
9066   arg2 = (uint16_t)jarg2;
9067   {
9068     try {
9069       (arg1)->SetWidth(arg2);
9070     } catch (std::out_of_range& e) {
9071       {
9072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9073       };
9074     } catch (std::exception& e) {
9075       {
9076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9077       };
9078     } catch (Dali::DaliException e) {
9079       {
9080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9081       };
9082     } catch (...) {
9083       {
9084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9085       };
9086     }
9087   }
9088
9089 }
9090
9091
9092 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9093   unsigned short jresult ;
9094   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9095   uint16_t result;
9096
9097   arg1 = (Dali::Uint16Pair *)jarg1;
9098   {
9099     try {
9100       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9101     } catch (std::out_of_range& e) {
9102       {
9103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9104       };
9105     } catch (std::exception& e) {
9106       {
9107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9108       };
9109     } catch (Dali::DaliException e) {
9110       {
9111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9112       };
9113     } catch (...) {
9114       {
9115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9116       };
9117     }
9118   }
9119
9120   jresult = result;
9121   return jresult;
9122 }
9123
9124
9125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9126   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9127   uint16_t arg2 ;
9128
9129   arg1 = (Dali::Uint16Pair *)jarg1;
9130   arg2 = (uint16_t)jarg2;
9131   {
9132     try {
9133       (arg1)->SetHeight(arg2);
9134     } catch (std::out_of_range& e) {
9135       {
9136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9137       };
9138     } catch (std::exception& e) {
9139       {
9140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9141       };
9142     } catch (Dali::DaliException e) {
9143       {
9144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9145       };
9146     } catch (...) {
9147       {
9148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9149       };
9150     }
9151   }
9152
9153 }
9154
9155
9156 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9157   unsigned short jresult ;
9158   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9159   uint16_t result;
9160
9161   arg1 = (Dali::Uint16Pair *)jarg1;
9162   {
9163     try {
9164       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9165     } catch (std::out_of_range& e) {
9166       {
9167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9168       };
9169     } catch (std::exception& e) {
9170       {
9171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9172       };
9173     } catch (Dali::DaliException e) {
9174       {
9175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9176       };
9177     } catch (...) {
9178       {
9179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9180       };
9181     }
9182   }
9183
9184   jresult = result;
9185   return jresult;
9186 }
9187
9188
9189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9190   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9191   uint16_t arg2 ;
9192
9193   arg1 = (Dali::Uint16Pair *)jarg1;
9194   arg2 = (uint16_t)jarg2;
9195   {
9196     try {
9197       (arg1)->SetX(arg2);
9198     } catch (std::out_of_range& e) {
9199       {
9200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9201       };
9202     } catch (std::exception& e) {
9203       {
9204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9205       };
9206     } catch (Dali::DaliException e) {
9207       {
9208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9209       };
9210     } catch (...) {
9211       {
9212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9213       };
9214     }
9215   }
9216
9217 }
9218
9219
9220 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9221   unsigned short jresult ;
9222   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9223   uint16_t result;
9224
9225   arg1 = (Dali::Uint16Pair *)jarg1;
9226   {
9227     try {
9228       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9229     } catch (std::out_of_range& e) {
9230       {
9231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9232       };
9233     } catch (std::exception& e) {
9234       {
9235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9236       };
9237     } catch (Dali::DaliException e) {
9238       {
9239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9240       };
9241     } catch (...) {
9242       {
9243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9244       };
9245     }
9246   }
9247
9248   jresult = result;
9249   return jresult;
9250 }
9251
9252
9253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9254   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9255   uint16_t arg2 ;
9256
9257   arg1 = (Dali::Uint16Pair *)jarg1;
9258   arg2 = (uint16_t)jarg2;
9259   {
9260     try {
9261       (arg1)->SetY(arg2);
9262     } catch (std::out_of_range& e) {
9263       {
9264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9265       };
9266     } catch (std::exception& e) {
9267       {
9268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9269       };
9270     } catch (Dali::DaliException e) {
9271       {
9272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9273       };
9274     } catch (...) {
9275       {
9276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9277       };
9278     }
9279   }
9280
9281 }
9282
9283
9284 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9285   unsigned short jresult ;
9286   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9287   uint16_t result;
9288
9289   arg1 = (Dali::Uint16Pair *)jarg1;
9290   {
9291     try {
9292       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9293     } catch (std::out_of_range& e) {
9294       {
9295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9296       };
9297     } catch (std::exception& e) {
9298       {
9299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9300       };
9301     } catch (Dali::DaliException e) {
9302       {
9303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9304       };
9305     } catch (...) {
9306       {
9307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9308       };
9309     }
9310   }
9311
9312   jresult = result;
9313   return jresult;
9314 }
9315
9316
9317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9318   void * jresult ;
9319   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9320   Dali::Uint16Pair *arg2 = 0 ;
9321   Dali::Uint16Pair *result = 0 ;
9322
9323   arg1 = (Dali::Uint16Pair *)jarg1;
9324   arg2 = (Dali::Uint16Pair *)jarg2;
9325   if (!arg2) {
9326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9327     return 0;
9328   }
9329   {
9330     try {
9331       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9332     } catch (std::out_of_range& e) {
9333       {
9334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9335       };
9336     } catch (std::exception& e) {
9337       {
9338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9339       };
9340     } catch (Dali::DaliException e) {
9341       {
9342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9343       };
9344     } catch (...) {
9345       {
9346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9347       };
9348     }
9349   }
9350
9351   jresult = (void *)result;
9352   return jresult;
9353 }
9354
9355
9356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9357   unsigned int jresult ;
9358   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9359   Dali::Uint16Pair *arg2 = 0 ;
9360   bool result;
9361
9362   arg1 = (Dali::Uint16Pair *)jarg1;
9363   arg2 = (Dali::Uint16Pair *)jarg2;
9364   if (!arg2) {
9365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9366     return 0;
9367   }
9368   {
9369     try {
9370       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9371     } catch (std::out_of_range& e) {
9372       {
9373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9374       };
9375     } catch (std::exception& e) {
9376       {
9377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9378       };
9379     } catch (Dali::DaliException e) {
9380       {
9381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9382       };
9383     } catch (...) {
9384       {
9385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9386       };
9387     }
9388   }
9389
9390   jresult = result;
9391   return jresult;
9392 }
9393
9394
9395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9396   unsigned int jresult ;
9397   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9398   Dali::Uint16Pair *arg2 = 0 ;
9399   bool result;
9400
9401   arg1 = (Dali::Uint16Pair *)jarg1;
9402   arg2 = (Dali::Uint16Pair *)jarg2;
9403   if (!arg2) {
9404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9405     return 0;
9406   }
9407   {
9408     try {
9409       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9410     } catch (std::out_of_range& e) {
9411       {
9412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9413       };
9414     } catch (std::exception& e) {
9415       {
9416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9417       };
9418     } catch (Dali::DaliException e) {
9419       {
9420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9421       };
9422     } catch (...) {
9423       {
9424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9425       };
9426     }
9427   }
9428
9429   jresult = result;
9430   return jresult;
9431 }
9432
9433
9434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9435   unsigned int jresult ;
9436   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9437   Dali::Uint16Pair *arg2 = 0 ;
9438   bool result;
9439
9440   arg1 = (Dali::Uint16Pair *)jarg1;
9441   arg2 = (Dali::Uint16Pair *)jarg2;
9442   if (!arg2) {
9443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9444     return 0;
9445   }
9446   {
9447     try {
9448       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9449     } catch (std::out_of_range& e) {
9450       {
9451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9452       };
9453     } catch (std::exception& e) {
9454       {
9455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9456       };
9457     } catch (Dali::DaliException e) {
9458       {
9459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9460       };
9461     } catch (...) {
9462       {
9463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9464       };
9465     }
9466   }
9467
9468   jresult = result;
9469   return jresult;
9470 }
9471
9472
9473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9474   unsigned int jresult ;
9475   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9476   Dali::Uint16Pair *arg2 = 0 ;
9477   bool result;
9478
9479   arg1 = (Dali::Uint16Pair *)jarg1;
9480   arg2 = (Dali::Uint16Pair *)jarg2;
9481   if (!arg2) {
9482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9483     return 0;
9484   }
9485   {
9486     try {
9487       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9488     } catch (std::out_of_range& e) {
9489       {
9490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9491       };
9492     } catch (std::exception& e) {
9493       {
9494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9495       };
9496     } catch (Dali::DaliException e) {
9497       {
9498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9499       };
9500     } catch (...) {
9501       {
9502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9503       };
9504     }
9505   }
9506
9507   jresult = result;
9508   return jresult;
9509 }
9510
9511
9512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9513   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9514
9515   arg1 = (Dali::Uint16Pair *)jarg1;
9516   {
9517     try {
9518       delete arg1;
9519     } catch (std::out_of_range& e) {
9520       {
9521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9522       };
9523     } catch (std::exception& e) {
9524       {
9525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9526       };
9527     } catch (Dali::DaliException e) {
9528       {
9529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9530       };
9531     } catch (...) {
9532       {
9533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9534       };
9535     }
9536   }
9537
9538 }
9539
9540
9541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9542   void * jresult ;
9543   Dali::Degree *result = 0 ;
9544
9545   {
9546     try {
9547       result = (Dali::Degree *)new Dali::Degree();
9548     } catch (std::out_of_range& e) {
9549       {
9550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9551       };
9552     } catch (std::exception& e) {
9553       {
9554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9555       };
9556     } catch (Dali::DaliException e) {
9557       {
9558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9559       };
9560     } catch (...) {
9561       {
9562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9563       };
9564     }
9565   }
9566
9567   jresult = (void *)result;
9568   return jresult;
9569 }
9570
9571
9572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9573   void * jresult ;
9574   float arg1 ;
9575   Dali::Degree *result = 0 ;
9576
9577   arg1 = (float)jarg1;
9578   {
9579     try {
9580       result = (Dali::Degree *)new Dali::Degree(arg1);
9581     } catch (std::out_of_range& e) {
9582       {
9583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9584       };
9585     } catch (std::exception& e) {
9586       {
9587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9588       };
9589     } catch (Dali::DaliException e) {
9590       {
9591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9592       };
9593     } catch (...) {
9594       {
9595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9596       };
9597     }
9598   }
9599
9600   jresult = (void *)result;
9601   return jresult;
9602 }
9603
9604
9605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9606   void * jresult ;
9607   Dali::Radian arg1 ;
9608   Dali::Radian *argp1 ;
9609   Dali::Degree *result = 0 ;
9610
9611   argp1 = (Dali::Radian *)jarg1;
9612   if (!argp1) {
9613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9614     return 0;
9615   }
9616   arg1 = *argp1;
9617   {
9618     try {
9619       result = (Dali::Degree *)new Dali::Degree(arg1);
9620     } catch (std::out_of_range& e) {
9621       {
9622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9623       };
9624     } catch (std::exception& e) {
9625       {
9626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9627       };
9628     } catch (Dali::DaliException e) {
9629       {
9630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9631       };
9632     } catch (...) {
9633       {
9634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9635       };
9636     }
9637   }
9638
9639   jresult = (void *)result;
9640   return jresult;
9641 }
9642
9643
9644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9645   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9646   float arg2 ;
9647
9648   arg1 = (Dali::Degree *)jarg1;
9649   arg2 = (float)jarg2;
9650   if (arg1) (arg1)->degree = arg2;
9651 }
9652
9653
9654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9655   float jresult ;
9656   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9657   float result;
9658
9659   arg1 = (Dali::Degree *)jarg1;
9660   result = (float) ((arg1)->degree);
9661   jresult = result;
9662   return jresult;
9663 }
9664
9665
9666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9667   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9668
9669   arg1 = (Dali::Degree *)jarg1;
9670   {
9671     try {
9672       delete arg1;
9673     } catch (std::out_of_range& e) {
9674       {
9675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9676       };
9677     } catch (std::exception& e) {
9678       {
9679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9680       };
9681     } catch (Dali::DaliException e) {
9682       {
9683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9684       };
9685     } catch (...) {
9686       {
9687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9688       };
9689     }
9690   }
9691
9692 }
9693
9694
9695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9696   void * jresult ;
9697   Dali::Radian *result = 0 ;
9698
9699   result = (Dali::Radian *)&Dali::ANGLE_360;
9700   jresult = (void *)result;
9701   return jresult;
9702 }
9703
9704
9705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9706   void * jresult ;
9707   Dali::Radian *result = 0 ;
9708
9709   result = (Dali::Radian *)&Dali::ANGLE_315;
9710   jresult = (void *)result;
9711   return jresult;
9712 }
9713
9714
9715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9716   void * jresult ;
9717   Dali::Radian *result = 0 ;
9718
9719   result = (Dali::Radian *)&Dali::ANGLE_270;
9720   jresult = (void *)result;
9721   return jresult;
9722 }
9723
9724
9725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9726   void * jresult ;
9727   Dali::Radian *result = 0 ;
9728
9729   result = (Dali::Radian *)&Dali::ANGLE_225;
9730   jresult = (void *)result;
9731   return jresult;
9732 }
9733
9734
9735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9736   void * jresult ;
9737   Dali::Radian *result = 0 ;
9738
9739   result = (Dali::Radian *)&Dali::ANGLE_180;
9740   jresult = (void *)result;
9741   return jresult;
9742 }
9743
9744
9745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9746   void * jresult ;
9747   Dali::Radian *result = 0 ;
9748
9749   result = (Dali::Radian *)&Dali::ANGLE_135;
9750   jresult = (void *)result;
9751   return jresult;
9752 }
9753
9754
9755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9756   void * jresult ;
9757   Dali::Radian *result = 0 ;
9758
9759   result = (Dali::Radian *)&Dali::ANGLE_120;
9760   jresult = (void *)result;
9761   return jresult;
9762 }
9763
9764
9765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9766   void * jresult ;
9767   Dali::Radian *result = 0 ;
9768
9769   result = (Dali::Radian *)&Dali::ANGLE_90;
9770   jresult = (void *)result;
9771   return jresult;
9772 }
9773
9774
9775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9776   void * jresult ;
9777   Dali::Radian *result = 0 ;
9778
9779   result = (Dali::Radian *)&Dali::ANGLE_60;
9780   jresult = (void *)result;
9781   return jresult;
9782 }
9783
9784
9785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9786   void * jresult ;
9787   Dali::Radian *result = 0 ;
9788
9789   result = (Dali::Radian *)&Dali::ANGLE_45;
9790   jresult = (void *)result;
9791   return jresult;
9792 }
9793
9794
9795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9796   void * jresult ;
9797   Dali::Radian *result = 0 ;
9798
9799   result = (Dali::Radian *)&Dali::ANGLE_30;
9800   jresult = (void *)result;
9801   return jresult;
9802 }
9803
9804
9805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9806   void * jresult ;
9807   Dali::Radian *result = 0 ;
9808
9809   result = (Dali::Radian *)&Dali::ANGLE_0;
9810   jresult = (void *)result;
9811   return jresult;
9812 }
9813
9814
9815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9816   unsigned int jresult ;
9817   Dali::Degree *arg1 = 0 ;
9818   Dali::Degree *arg2 = 0 ;
9819   bool result;
9820
9821   arg1 = (Dali::Degree *)jarg1;
9822   if (!arg1) {
9823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9824     return 0;
9825   }
9826   arg2 = (Dali::Degree *)jarg2;
9827   if (!arg2) {
9828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9829     return 0;
9830   }
9831   {
9832     try {
9833       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9834     } catch (std::out_of_range& e) {
9835       {
9836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9837       };
9838     } catch (std::exception& e) {
9839       {
9840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9841       };
9842     } catch (Dali::DaliException e) {
9843       {
9844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9845       };
9846     } catch (...) {
9847       {
9848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9849       };
9850     }
9851   }
9852
9853   jresult = result;
9854   return jresult;
9855 }
9856
9857
9858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9859   unsigned int jresult ;
9860   Dali::Degree *arg1 = 0 ;
9861   Dali::Degree *arg2 = 0 ;
9862   bool result;
9863
9864   arg1 = (Dali::Degree *)jarg1;
9865   if (!arg1) {
9866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9867     return 0;
9868   }
9869   arg2 = (Dali::Degree *)jarg2;
9870   if (!arg2) {
9871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9872     return 0;
9873   }
9874   {
9875     try {
9876       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9877     } catch (std::out_of_range& e) {
9878       {
9879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9880       };
9881     } catch (std::exception& e) {
9882       {
9883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9884       };
9885     } catch (Dali::DaliException e) {
9886       {
9887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9888       };
9889     } catch (...) {
9890       {
9891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9892       };
9893     }
9894   }
9895
9896   jresult = result;
9897   return jresult;
9898 }
9899
9900
9901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9902   void * jresult ;
9903   Dali::Degree arg1 ;
9904   float arg2 ;
9905   float arg3 ;
9906   Dali::Degree *argp1 ;
9907   Dali::Degree result;
9908
9909   argp1 = (Dali::Degree *)jarg1;
9910   if (!argp1) {
9911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9912     return 0;
9913   }
9914   arg1 = *argp1;
9915   arg2 = (float)jarg2;
9916   arg3 = (float)jarg3;
9917   {
9918     try {
9919       result = Dali::Clamp(arg1,arg2,arg3);
9920     } catch (std::out_of_range& e) {
9921       {
9922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9923       };
9924     } catch (std::exception& e) {
9925       {
9926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9927       };
9928     } catch (Dali::DaliException e) {
9929       {
9930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9931       };
9932     } catch (...) {
9933       {
9934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9935       };
9936     }
9937   }
9938
9939   jresult = new Dali::Degree((const Dali::Degree &)result);
9940   return jresult;
9941 }
9942
9943
9944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9945   void * jresult ;
9946   Dali::Radian *result = 0 ;
9947
9948   {
9949     try {
9950       result = (Dali::Radian *)new Dali::Radian();
9951     } catch (std::out_of_range& e) {
9952       {
9953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9954       };
9955     } catch (std::exception& e) {
9956       {
9957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9958       };
9959     } catch (Dali::DaliException e) {
9960       {
9961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9962       };
9963     } catch (...) {
9964       {
9965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9966       };
9967     }
9968   }
9969
9970   jresult = (void *)result;
9971   return jresult;
9972 }
9973
9974
9975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9976   void * jresult ;
9977   float arg1 ;
9978   Dali::Radian *result = 0 ;
9979
9980   arg1 = (float)jarg1;
9981   {
9982     try {
9983       result = (Dali::Radian *)new Dali::Radian(arg1);
9984     } catch (std::out_of_range& e) {
9985       {
9986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9987       };
9988     } catch (std::exception& e) {
9989       {
9990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9991       };
9992     } catch (Dali::DaliException e) {
9993       {
9994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9995       };
9996     } catch (...) {
9997       {
9998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9999       };
10000     }
10001   }
10002
10003   jresult = (void *)result;
10004   return jresult;
10005 }
10006
10007
10008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10009   void * jresult ;
10010   Dali::Degree arg1 ;
10011   Dali::Degree *argp1 ;
10012   Dali::Radian *result = 0 ;
10013
10014   argp1 = (Dali::Degree *)jarg1;
10015   if (!argp1) {
10016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10017     return 0;
10018   }
10019   arg1 = *argp1;
10020   {
10021     try {
10022       result = (Dali::Radian *)new Dali::Radian(arg1);
10023     } catch (std::out_of_range& e) {
10024       {
10025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10026       };
10027     } catch (std::exception& e) {
10028       {
10029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10030       };
10031     } catch (Dali::DaliException e) {
10032       {
10033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10034       };
10035     } catch (...) {
10036       {
10037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10038       };
10039     }
10040   }
10041
10042   jresult = (void *)result;
10043   return jresult;
10044 }
10045
10046
10047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10048   void * jresult ;
10049   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10050   float arg2 ;
10051   Dali::Radian *result = 0 ;
10052
10053   arg1 = (Dali::Radian *)jarg1;
10054   arg2 = (float)jarg2;
10055   {
10056     try {
10057       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10058     } catch (std::out_of_range& e) {
10059       {
10060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10061       };
10062     } catch (std::exception& e) {
10063       {
10064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10065       };
10066     } catch (Dali::DaliException e) {
10067       {
10068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10069       };
10070     } catch (...) {
10071       {
10072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10073       };
10074     }
10075   }
10076
10077   jresult = (void *)result;
10078   return jresult;
10079 }
10080
10081
10082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10083   void * jresult ;
10084   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10085   Dali::Degree arg2 ;
10086   Dali::Degree *argp2 ;
10087   Dali::Radian *result = 0 ;
10088
10089   arg1 = (Dali::Radian *)jarg1;
10090   argp2 = (Dali::Degree *)jarg2;
10091   if (!argp2) {
10092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10093     return 0;
10094   }
10095   arg2 = *argp2;
10096   {
10097     try {
10098       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10099     } catch (std::out_of_range& e) {
10100       {
10101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10102       };
10103     } catch (std::exception& e) {
10104       {
10105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10106       };
10107     } catch (Dali::DaliException e) {
10108       {
10109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10110       };
10111     } catch (...) {
10112       {
10113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10114       };
10115     }
10116   }
10117
10118   jresult = (void *)result;
10119   return jresult;
10120 }
10121
10122
10123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10124   float jresult ;
10125   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10126   float result;
10127
10128   arg1 = (Dali::Radian *)jarg1;
10129   {
10130     try {
10131       result = (float)((Dali::Radian const *)arg1)->operator float();
10132     } catch (std::out_of_range& e) {
10133       {
10134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10135       };
10136     } catch (std::exception& e) {
10137       {
10138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10139       };
10140     } catch (Dali::DaliException e) {
10141       {
10142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10143       };
10144     } catch (...) {
10145       {
10146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10147       };
10148     }
10149   }
10150
10151   jresult = result;
10152   return jresult;
10153 }
10154
10155
10156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10157   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10158   float arg2 ;
10159
10160   arg1 = (Dali::Radian *)jarg1;
10161   arg2 = (float)jarg2;
10162   if (arg1) (arg1)->radian = arg2;
10163 }
10164
10165
10166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10167   float jresult ;
10168   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10169   float result;
10170
10171   arg1 = (Dali::Radian *)jarg1;
10172   result = (float) ((arg1)->radian);
10173   jresult = result;
10174   return jresult;
10175 }
10176
10177
10178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10179   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10180
10181   arg1 = (Dali::Radian *)jarg1;
10182   {
10183     try {
10184       delete arg1;
10185     } catch (std::out_of_range& e) {
10186       {
10187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10188       };
10189     } catch (std::exception& e) {
10190       {
10191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10192       };
10193     } catch (Dali::DaliException e) {
10194       {
10195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10196       };
10197     } catch (...) {
10198       {
10199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10200       };
10201     }
10202   }
10203
10204 }
10205
10206
10207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10208   unsigned int jresult ;
10209   Dali::Radian arg1 ;
10210   Dali::Radian arg2 ;
10211   Dali::Radian *argp1 ;
10212   Dali::Radian *argp2 ;
10213   bool result;
10214
10215   argp1 = (Dali::Radian *)jarg1;
10216   if (!argp1) {
10217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10218     return 0;
10219   }
10220   arg1 = *argp1;
10221   argp2 = (Dali::Radian *)jarg2;
10222   if (!argp2) {
10223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10224     return 0;
10225   }
10226   arg2 = *argp2;
10227   {
10228     try {
10229       result = (bool)Dali::operator ==(arg1,arg2);
10230     } catch (std::out_of_range& e) {
10231       {
10232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (std::exception& e) {
10235       {
10236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10237       };
10238     } catch (Dali::DaliException e) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10241       };
10242     } catch (...) {
10243       {
10244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10245       };
10246     }
10247   }
10248
10249   jresult = result;
10250   return jresult;
10251 }
10252
10253
10254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10255   unsigned int jresult ;
10256   Dali::Radian arg1 ;
10257   Dali::Radian arg2 ;
10258   Dali::Radian *argp1 ;
10259   Dali::Radian *argp2 ;
10260   bool result;
10261
10262   argp1 = (Dali::Radian *)jarg1;
10263   if (!argp1) {
10264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10265     return 0;
10266   }
10267   arg1 = *argp1;
10268   argp2 = (Dali::Radian *)jarg2;
10269   if (!argp2) {
10270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10271     return 0;
10272   }
10273   arg2 = *argp2;
10274   {
10275     try {
10276       result = (bool)Dali::operator !=(arg1,arg2);
10277     } catch (std::out_of_range& e) {
10278       {
10279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10280       };
10281     } catch (std::exception& e) {
10282       {
10283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10284       };
10285     } catch (Dali::DaliException e) {
10286       {
10287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10288       };
10289     } catch (...) {
10290       {
10291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10292       };
10293     }
10294   }
10295
10296   jresult = result;
10297   return jresult;
10298 }
10299
10300
10301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10302   unsigned int jresult ;
10303   Dali::Radian arg1 ;
10304   Dali::Degree arg2 ;
10305   Dali::Radian *argp1 ;
10306   Dali::Degree *argp2 ;
10307   bool result;
10308
10309   argp1 = (Dali::Radian *)jarg1;
10310   if (!argp1) {
10311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10312     return 0;
10313   }
10314   arg1 = *argp1;
10315   argp2 = (Dali::Degree *)jarg2;
10316   if (!argp2) {
10317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10318     return 0;
10319   }
10320   arg2 = *argp2;
10321   {
10322     try {
10323       result = (bool)Dali::operator ==(arg1,arg2);
10324     } catch (std::out_of_range& e) {
10325       {
10326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (std::exception& e) {
10329       {
10330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10331       };
10332     } catch (Dali::DaliException e) {
10333       {
10334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10335       };
10336     } catch (...) {
10337       {
10338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10339       };
10340     }
10341   }
10342
10343   jresult = result;
10344   return jresult;
10345 }
10346
10347
10348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10349   unsigned int jresult ;
10350   Dali::Radian arg1 ;
10351   Dali::Degree arg2 ;
10352   Dali::Radian *argp1 ;
10353   Dali::Degree *argp2 ;
10354   bool result;
10355
10356   argp1 = (Dali::Radian *)jarg1;
10357   if (!argp1) {
10358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10359     return 0;
10360   }
10361   arg1 = *argp1;
10362   argp2 = (Dali::Degree *)jarg2;
10363   if (!argp2) {
10364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10365     return 0;
10366   }
10367   arg2 = *argp2;
10368   {
10369     try {
10370       result = (bool)Dali::operator !=(arg1,arg2);
10371     } catch (std::out_of_range& e) {
10372       {
10373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (std::exception& e) {
10376       {
10377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10378       };
10379     } catch (Dali::DaliException e) {
10380       {
10381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10382       };
10383     } catch (...) {
10384       {
10385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10386       };
10387     }
10388   }
10389
10390   jresult = result;
10391   return jresult;
10392 }
10393
10394
10395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10396   unsigned int jresult ;
10397   Dali::Degree arg1 ;
10398   Dali::Radian arg2 ;
10399   Dali::Degree *argp1 ;
10400   Dali::Radian *argp2 ;
10401   bool result;
10402
10403   argp1 = (Dali::Degree *)jarg1;
10404   if (!argp1) {
10405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10406     return 0;
10407   }
10408   arg1 = *argp1;
10409   argp2 = (Dali::Radian *)jarg2;
10410   if (!argp2) {
10411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10412     return 0;
10413   }
10414   arg2 = *argp2;
10415   {
10416     try {
10417       result = (bool)Dali::operator ==(arg1,arg2);
10418     } catch (std::out_of_range& e) {
10419       {
10420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10421       };
10422     } catch (std::exception& e) {
10423       {
10424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10425       };
10426     } catch (Dali::DaliException e) {
10427       {
10428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10429       };
10430     } catch (...) {
10431       {
10432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10433       };
10434     }
10435   }
10436
10437   jresult = result;
10438   return jresult;
10439 }
10440
10441
10442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10443   unsigned int jresult ;
10444   Dali::Degree arg1 ;
10445   Dali::Radian arg2 ;
10446   Dali::Degree *argp1 ;
10447   Dali::Radian *argp2 ;
10448   bool result;
10449
10450   argp1 = (Dali::Degree *)jarg1;
10451   if (!argp1) {
10452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10453     return 0;
10454   }
10455   arg1 = *argp1;
10456   argp2 = (Dali::Radian *)jarg2;
10457   if (!argp2) {
10458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10459     return 0;
10460   }
10461   arg2 = *argp2;
10462   {
10463     try {
10464       result = (bool)Dali::operator !=(arg1,arg2);
10465     } catch (std::out_of_range& e) {
10466       {
10467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10468       };
10469     } catch (std::exception& e) {
10470       {
10471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10472       };
10473     } catch (Dali::DaliException e) {
10474       {
10475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10476       };
10477     } catch (...) {
10478       {
10479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10480       };
10481     }
10482   }
10483
10484   jresult = result;
10485   return jresult;
10486 }
10487
10488
10489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10490   unsigned int jresult ;
10491   Dali::Radian arg1 ;
10492   Dali::Radian arg2 ;
10493   Dali::Radian *argp1 ;
10494   Dali::Radian *argp2 ;
10495   bool result;
10496
10497   argp1 = (Dali::Radian *)jarg1;
10498   if (!argp1) {
10499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10500     return 0;
10501   }
10502   arg1 = *argp1;
10503   argp2 = (Dali::Radian *)jarg2;
10504   if (!argp2) {
10505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10506     return 0;
10507   }
10508   arg2 = *argp2;
10509   {
10510     try {
10511       result = (bool)Dali::operator >(arg1,arg2);
10512     } catch (std::out_of_range& e) {
10513       {
10514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10515       };
10516     } catch (std::exception& e) {
10517       {
10518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10519       };
10520     } catch (Dali::DaliException e) {
10521       {
10522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10523       };
10524     } catch (...) {
10525       {
10526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10527       };
10528     }
10529   }
10530
10531   jresult = result;
10532   return jresult;
10533 }
10534
10535
10536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10537   unsigned int jresult ;
10538   Dali::Radian arg1 ;
10539   Dali::Degree arg2 ;
10540   Dali::Radian *argp1 ;
10541   Dali::Degree *argp2 ;
10542   bool result;
10543
10544   argp1 = (Dali::Radian *)jarg1;
10545   if (!argp1) {
10546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10547     return 0;
10548   }
10549   arg1 = *argp1;
10550   argp2 = (Dali::Degree *)jarg2;
10551   if (!argp2) {
10552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10553     return 0;
10554   }
10555   arg2 = *argp2;
10556   {
10557     try {
10558       result = (bool)Dali::operator >(arg1,arg2);
10559     } catch (std::out_of_range& e) {
10560       {
10561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10562       };
10563     } catch (std::exception& e) {
10564       {
10565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10566       };
10567     } catch (Dali::DaliException e) {
10568       {
10569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10570       };
10571     } catch (...) {
10572       {
10573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10574       };
10575     }
10576   }
10577
10578   jresult = result;
10579   return jresult;
10580 }
10581
10582
10583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10584   unsigned int jresult ;
10585   Dali::Degree arg1 ;
10586   Dali::Radian arg2 ;
10587   Dali::Degree *argp1 ;
10588   Dali::Radian *argp2 ;
10589   bool result;
10590
10591   argp1 = (Dali::Degree *)jarg1;
10592   if (!argp1) {
10593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10594     return 0;
10595   }
10596   arg1 = *argp1;
10597   argp2 = (Dali::Radian *)jarg2;
10598   if (!argp2) {
10599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10600     return 0;
10601   }
10602   arg2 = *argp2;
10603   {
10604     try {
10605       result = (bool)Dali::operator >(arg1,arg2);
10606     } catch (std::out_of_range& e) {
10607       {
10608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10609       };
10610     } catch (std::exception& e) {
10611       {
10612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10613       };
10614     } catch (Dali::DaliException e) {
10615       {
10616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10617       };
10618     } catch (...) {
10619       {
10620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10621       };
10622     }
10623   }
10624
10625   jresult = result;
10626   return jresult;
10627 }
10628
10629
10630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10631   unsigned int jresult ;
10632   Dali::Radian arg1 ;
10633   Dali::Radian arg2 ;
10634   Dali::Radian *argp1 ;
10635   Dali::Radian *argp2 ;
10636   bool result;
10637
10638   argp1 = (Dali::Radian *)jarg1;
10639   if (!argp1) {
10640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10641     return 0;
10642   }
10643   arg1 = *argp1;
10644   argp2 = (Dali::Radian *)jarg2;
10645   if (!argp2) {
10646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10647     return 0;
10648   }
10649   arg2 = *argp2;
10650   {
10651     try {
10652       result = (bool)Dali::operator <(arg1,arg2);
10653     } catch (std::out_of_range& e) {
10654       {
10655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10656       };
10657     } catch (std::exception& e) {
10658       {
10659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10660       };
10661     } catch (Dali::DaliException e) {
10662       {
10663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10664       };
10665     } catch (...) {
10666       {
10667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10668       };
10669     }
10670   }
10671
10672   jresult = result;
10673   return jresult;
10674 }
10675
10676
10677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10678   unsigned int jresult ;
10679   Dali::Radian arg1 ;
10680   Dali::Degree arg2 ;
10681   Dali::Radian *argp1 ;
10682   Dali::Degree *argp2 ;
10683   bool result;
10684
10685   argp1 = (Dali::Radian *)jarg1;
10686   if (!argp1) {
10687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10688     return 0;
10689   }
10690   arg1 = *argp1;
10691   argp2 = (Dali::Degree *)jarg2;
10692   if (!argp2) {
10693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10694     return 0;
10695   }
10696   arg2 = *argp2;
10697   {
10698     try {
10699       result = (bool)Dali::operator <(arg1,arg2);
10700     } catch (std::out_of_range& e) {
10701       {
10702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (std::exception& e) {
10705       {
10706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10707       };
10708     } catch (Dali::DaliException e) {
10709       {
10710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10711       };
10712     } catch (...) {
10713       {
10714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10715       };
10716     }
10717   }
10718
10719   jresult = result;
10720   return jresult;
10721 }
10722
10723
10724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10725   unsigned int jresult ;
10726   Dali::Degree arg1 ;
10727   Dali::Radian arg2 ;
10728   Dali::Degree *argp1 ;
10729   Dali::Radian *argp2 ;
10730   bool result;
10731
10732   argp1 = (Dali::Degree *)jarg1;
10733   if (!argp1) {
10734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10735     return 0;
10736   }
10737   arg1 = *argp1;
10738   argp2 = (Dali::Radian *)jarg2;
10739   if (!argp2) {
10740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10741     return 0;
10742   }
10743   arg2 = *argp2;
10744   {
10745     try {
10746       result = (bool)Dali::operator <(arg1,arg2);
10747     } catch (std::out_of_range& e) {
10748       {
10749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10750       };
10751     } catch (std::exception& e) {
10752       {
10753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10754       };
10755     } catch (Dali::DaliException e) {
10756       {
10757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10758       };
10759     } catch (...) {
10760       {
10761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10762       };
10763     }
10764   }
10765
10766   jresult = result;
10767   return jresult;
10768 }
10769
10770
10771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10772   void * jresult ;
10773   Dali::Radian arg1 ;
10774   float arg2 ;
10775   Dali::Radian *argp1 ;
10776   Dali::Radian result;
10777
10778   argp1 = (Dali::Radian *)jarg1;
10779   if (!argp1) {
10780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10781     return 0;
10782   }
10783   arg1 = *argp1;
10784   arg2 = (float)jarg2;
10785   {
10786     try {
10787       result = Dali::operator *(arg1,arg2);
10788     } catch (std::out_of_range& e) {
10789       {
10790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10791       };
10792     } catch (std::exception& e) {
10793       {
10794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10795       };
10796     } catch (Dali::DaliException e) {
10797       {
10798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10799       };
10800     } catch (...) {
10801       {
10802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10803       };
10804     }
10805   }
10806
10807   jresult = new Dali::Radian((const Dali::Radian &)result);
10808   return jresult;
10809 }
10810
10811
10812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10813   void * jresult ;
10814   Dali::Radian arg1 ;
10815   Dali::Radian *argp1 ;
10816   Dali::Radian result;
10817
10818   argp1 = (Dali::Radian *)jarg1;
10819   if (!argp1) {
10820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10821     return 0;
10822   }
10823   arg1 = *argp1;
10824   {
10825     try {
10826       result = Dali::operator -(arg1);
10827     } catch (std::out_of_range& e) {
10828       {
10829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10830       };
10831     } catch (std::exception& e) {
10832       {
10833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10834       };
10835     } catch (Dali::DaliException e) {
10836       {
10837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10838       };
10839     } catch (...) {
10840       {
10841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10842       };
10843     }
10844   }
10845
10846   jresult = new Dali::Radian((const Dali::Radian &)result);
10847   return jresult;
10848 }
10849
10850
10851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10852   void * jresult ;
10853   Dali::Radian arg1 ;
10854   float arg2 ;
10855   float arg3 ;
10856   Dali::Radian *argp1 ;
10857   Dali::Radian result;
10858
10859   argp1 = (Dali::Radian *)jarg1;
10860   if (!argp1) {
10861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10862     return 0;
10863   }
10864   arg1 = *argp1;
10865   arg2 = (float)jarg2;
10866   arg3 = (float)jarg3;
10867   {
10868     try {
10869       result = Dali::Clamp(arg1,arg2,arg3);
10870     } catch (std::out_of_range& e) {
10871       {
10872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10873       };
10874     } catch (std::exception& e) {
10875       {
10876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10877       };
10878     } catch (Dali::DaliException e) {
10879       {
10880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10881       };
10882     } catch (...) {
10883       {
10884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10885       };
10886     }
10887   }
10888
10889   jresult = new Dali::Radian((const Dali::Radian &)result);
10890   return jresult;
10891 }
10892
10893
10894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10895   void * jresult ;
10896   Dali::Quaternion *result = 0 ;
10897
10898   {
10899     try {
10900       result = (Dali::Quaternion *)new Dali::Quaternion();
10901     } catch (std::out_of_range& e) {
10902       {
10903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10904       };
10905     } catch (std::exception& e) {
10906       {
10907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10908       };
10909     } catch (Dali::DaliException e) {
10910       {
10911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10912       };
10913     } catch (...) {
10914       {
10915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10916       };
10917     }
10918   }
10919
10920   jresult = (void *)result;
10921   return jresult;
10922 }
10923
10924
10925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10926   void * jresult ;
10927   Dali::Radian arg1 ;
10928   Dali::Vector3 *arg2 = 0 ;
10929   Dali::Radian *argp1 ;
10930   Dali::Quaternion *result = 0 ;
10931
10932   argp1 = (Dali::Radian *)jarg1;
10933   if (!argp1) {
10934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10935     return 0;
10936   }
10937   arg1 = *argp1;
10938   arg2 = (Dali::Vector3 *)jarg2;
10939   if (!arg2) {
10940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10941     return 0;
10942   }
10943   {
10944     try {
10945       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10946     } catch (std::out_of_range& e) {
10947       {
10948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10949       };
10950     } catch (std::exception& e) {
10951       {
10952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10953       };
10954     } catch (Dali::DaliException e) {
10955       {
10956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10957       };
10958     } catch (...) {
10959       {
10960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10961       };
10962     }
10963   }
10964
10965   jresult = (void *)result;
10966   return jresult;
10967 }
10968
10969
10970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10971   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10972
10973   arg1 = (Dali::Quaternion *)jarg1;
10974   {
10975     try {
10976       delete arg1;
10977     } catch (std::out_of_range& e) {
10978       {
10979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10980       };
10981     } catch (std::exception& e) {
10982       {
10983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10984       };
10985     } catch (Dali::DaliException e) {
10986       {
10987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10988       };
10989     } catch (...) {
10990       {
10991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10992       };
10993     }
10994   }
10995
10996 }
10997
10998
10999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11000   void * jresult ;
11001   Dali::Quaternion *result = 0 ;
11002
11003   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11004   jresult = (void *)result;
11005   return jresult;
11006 }
11007
11008
11009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11010   unsigned int jresult ;
11011   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11012   bool result;
11013
11014   arg1 = (Dali::Quaternion *)jarg1;
11015   {
11016     try {
11017       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11018     } catch (std::out_of_range& e) {
11019       {
11020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11021       };
11022     } catch (std::exception& e) {
11023       {
11024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11025       };
11026     } catch (Dali::DaliException e) {
11027       {
11028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11029       };
11030     } catch (...) {
11031       {
11032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11033       };
11034     }
11035   }
11036
11037   jresult = result;
11038   return jresult;
11039 }
11040
11041
11042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11043   unsigned int jresult ;
11044   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11045   Dali::Vector3 *arg2 = 0 ;
11046   Dali::Radian *arg3 = 0 ;
11047   bool result;
11048
11049   arg1 = (Dali::Quaternion *)jarg1;
11050   arg2 = (Dali::Vector3 *)jarg2;
11051   if (!arg2) {
11052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11053     return 0;
11054   }
11055   arg3 = (Dali::Radian *)jarg3;
11056   if (!arg3) {
11057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11058     return 0;
11059   }
11060   {
11061     try {
11062       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11063     } catch (std::out_of_range& e) {
11064       {
11065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11066       };
11067     } catch (std::exception& e) {
11068       {
11069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11070       };
11071     } catch (Dali::DaliException e) {
11072       {
11073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11074       };
11075     } catch (...) {
11076       {
11077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11078       };
11079     }
11080   }
11081
11082   jresult = result;
11083   return jresult;
11084 }
11085
11086
11087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11088   void * jresult ;
11089   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11090   Dali::Quaternion *arg2 = 0 ;
11091   Dali::Quaternion result;
11092
11093   arg1 = (Dali::Quaternion *)jarg1;
11094   arg2 = (Dali::Quaternion *)jarg2;
11095   if (!arg2) {
11096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11097     return 0;
11098   }
11099   {
11100     try {
11101       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11102     } catch (std::out_of_range& e) {
11103       {
11104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11105       };
11106     } catch (std::exception& e) {
11107       {
11108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11109       };
11110     } catch (Dali::DaliException e) {
11111       {
11112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11113       };
11114     } catch (...) {
11115       {
11116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11117       };
11118     }
11119   }
11120
11121   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11122   return jresult;
11123 }
11124
11125
11126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11127   void * jresult ;
11128   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11129   Dali::Quaternion *arg2 = 0 ;
11130   Dali::Quaternion result;
11131
11132   arg1 = (Dali::Quaternion *)jarg1;
11133   arg2 = (Dali::Quaternion *)jarg2;
11134   if (!arg2) {
11135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11136     return 0;
11137   }
11138   {
11139     try {
11140       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11141     } catch (std::out_of_range& e) {
11142       {
11143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11144       };
11145     } catch (std::exception& e) {
11146       {
11147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11148       };
11149     } catch (Dali::DaliException e) {
11150       {
11151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11152       };
11153     } catch (...) {
11154       {
11155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11156       };
11157     }
11158   }
11159
11160   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11161   return jresult;
11162 }
11163
11164
11165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11166   void * jresult ;
11167   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11168   Dali::Quaternion *arg2 = 0 ;
11169   Dali::Quaternion result;
11170
11171   arg1 = (Dali::Quaternion *)jarg1;
11172   arg2 = (Dali::Quaternion *)jarg2;
11173   if (!arg2) {
11174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11175     return 0;
11176   }
11177   {
11178     try {
11179       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11180     } catch (std::out_of_range& e) {
11181       {
11182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11183       };
11184     } catch (std::exception& e) {
11185       {
11186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11187       };
11188     } catch (Dali::DaliException e) {
11189       {
11190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11191       };
11192     } catch (...) {
11193       {
11194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11195       };
11196     }
11197   }
11198
11199   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11200   return jresult;
11201 }
11202
11203
11204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11205   void * jresult ;
11206   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11207   Dali::Vector3 *arg2 = 0 ;
11208   Dali::Vector3 result;
11209
11210   arg1 = (Dali::Quaternion *)jarg1;
11211   arg2 = (Dali::Vector3 *)jarg2;
11212   if (!arg2) {
11213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11214     return 0;
11215   }
11216   {
11217     try {
11218       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11219     } catch (std::out_of_range& e) {
11220       {
11221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11222       };
11223     } catch (std::exception& e) {
11224       {
11225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11226       };
11227     } catch (Dali::DaliException e) {
11228       {
11229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11230       };
11231     } catch (...) {
11232       {
11233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11234       };
11235     }
11236   }
11237
11238   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11239   return jresult;
11240 }
11241
11242
11243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11244   void * jresult ;
11245   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11246   Dali::Quaternion *arg2 = 0 ;
11247   Dali::Quaternion result;
11248
11249   arg1 = (Dali::Quaternion *)jarg1;
11250   arg2 = (Dali::Quaternion *)jarg2;
11251   if (!arg2) {
11252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11253     return 0;
11254   }
11255   {
11256     try {
11257       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11258     } catch (std::out_of_range& e) {
11259       {
11260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11261       };
11262     } catch (std::exception& e) {
11263       {
11264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11265       };
11266     } catch (Dali::DaliException e) {
11267       {
11268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11269       };
11270     } catch (...) {
11271       {
11272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11273       };
11274     }
11275   }
11276
11277   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11278   return jresult;
11279 }
11280
11281
11282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11283   void * jresult ;
11284   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11285   float arg2 ;
11286   Dali::Quaternion result;
11287
11288   arg1 = (Dali::Quaternion *)jarg1;
11289   arg2 = (float)jarg2;
11290   {
11291     try {
11292       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11293     } catch (std::out_of_range& e) {
11294       {
11295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11296       };
11297     } catch (std::exception& e) {
11298       {
11299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11300       };
11301     } catch (Dali::DaliException e) {
11302       {
11303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11304       };
11305     } catch (...) {
11306       {
11307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11308       };
11309     }
11310   }
11311
11312   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11313   return jresult;
11314 }
11315
11316
11317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11318   void * jresult ;
11319   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11320   float arg2 ;
11321   Dali::Quaternion result;
11322
11323   arg1 = (Dali::Quaternion *)jarg1;
11324   arg2 = (float)jarg2;
11325   {
11326     try {
11327       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11328     } catch (std::out_of_range& e) {
11329       {
11330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11331       };
11332     } catch (std::exception& e) {
11333       {
11334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11335       };
11336     } catch (Dali::DaliException e) {
11337       {
11338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11339       };
11340     } catch (...) {
11341       {
11342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11343       };
11344     }
11345   }
11346
11347   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11348   return jresult;
11349 }
11350
11351
11352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11353   void * jresult ;
11354   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11355   Dali::Quaternion result;
11356
11357   arg1 = (Dali::Quaternion *)jarg1;
11358   {
11359     try {
11360       result = ((Dali::Quaternion const *)arg1)->operator -();
11361     } catch (std::out_of_range& e) {
11362       {
11363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11364       };
11365     } catch (std::exception& e) {
11366       {
11367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11368       };
11369     } catch (Dali::DaliException e) {
11370       {
11371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11372       };
11373     } catch (...) {
11374       {
11375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11376       };
11377     }
11378   }
11379
11380   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11381   return jresult;
11382 }
11383
11384
11385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11386   void * jresult ;
11387   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11388   Dali::Quaternion *arg2 = 0 ;
11389   Dali::Quaternion *result = 0 ;
11390
11391   arg1 = (Dali::Quaternion *)jarg1;
11392   arg2 = (Dali::Quaternion *)jarg2;
11393   if (!arg2) {
11394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11395     return 0;
11396   }
11397   {
11398     try {
11399       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11400     } catch (std::out_of_range& e) {
11401       {
11402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11403       };
11404     } catch (std::exception& e) {
11405       {
11406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11407       };
11408     } catch (Dali::DaliException e) {
11409       {
11410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11411       };
11412     } catch (...) {
11413       {
11414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11415       };
11416     }
11417   }
11418
11419   jresult = (void *)result;
11420   return jresult;
11421 }
11422
11423
11424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11425   void * jresult ;
11426   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11427   Dali::Quaternion *arg2 = 0 ;
11428   Dali::Quaternion *result = 0 ;
11429
11430   arg1 = (Dali::Quaternion *)jarg1;
11431   arg2 = (Dali::Quaternion *)jarg2;
11432   if (!arg2) {
11433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11434     return 0;
11435   }
11436   {
11437     try {
11438       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11439     } catch (std::out_of_range& e) {
11440       {
11441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11442       };
11443     } catch (std::exception& e) {
11444       {
11445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11446       };
11447     } catch (Dali::DaliException e) {
11448       {
11449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11450       };
11451     } catch (...) {
11452       {
11453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11454       };
11455     }
11456   }
11457
11458   jresult = (void *)result;
11459   return jresult;
11460 }
11461
11462
11463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11464   void * jresult ;
11465   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11466   Dali::Quaternion *arg2 = 0 ;
11467   Dali::Quaternion *result = 0 ;
11468
11469   arg1 = (Dali::Quaternion *)jarg1;
11470   arg2 = (Dali::Quaternion *)jarg2;
11471   if (!arg2) {
11472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11473     return 0;
11474   }
11475   {
11476     try {
11477       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11478     } catch (std::out_of_range& e) {
11479       {
11480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11481       };
11482     } catch (std::exception& e) {
11483       {
11484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11485       };
11486     } catch (Dali::DaliException e) {
11487       {
11488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11489       };
11490     } catch (...) {
11491       {
11492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11493       };
11494     }
11495   }
11496
11497   jresult = (void *)result;
11498   return jresult;
11499 }
11500
11501
11502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11503   void * jresult ;
11504   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11505   float arg2 ;
11506   Dali::Quaternion *result = 0 ;
11507
11508   arg1 = (Dali::Quaternion *)jarg1;
11509   arg2 = (float)jarg2;
11510   {
11511     try {
11512       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11513     } catch (std::out_of_range& e) {
11514       {
11515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11516       };
11517     } catch (std::exception& e) {
11518       {
11519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11520       };
11521     } catch (Dali::DaliException e) {
11522       {
11523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11524       };
11525     } catch (...) {
11526       {
11527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11528       };
11529     }
11530   }
11531
11532   jresult = (void *)result;
11533   return jresult;
11534 }
11535
11536
11537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11538   void * jresult ;
11539   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11540   float arg2 ;
11541   Dali::Quaternion *result = 0 ;
11542
11543   arg1 = (Dali::Quaternion *)jarg1;
11544   arg2 = (float)jarg2;
11545   {
11546     try {
11547       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11548     } catch (std::out_of_range& e) {
11549       {
11550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11551       };
11552     } catch (std::exception& e) {
11553       {
11554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11555       };
11556     } catch (Dali::DaliException e) {
11557       {
11558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11559       };
11560     } catch (...) {
11561       {
11562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11563       };
11564     }
11565   }
11566
11567   jresult = (void *)result;
11568   return jresult;
11569 }
11570
11571
11572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11573   unsigned int jresult ;
11574   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11575   Dali::Quaternion *arg2 = 0 ;
11576   bool result;
11577
11578   arg1 = (Dali::Quaternion *)jarg1;
11579   arg2 = (Dali::Quaternion *)jarg2;
11580   if (!arg2) {
11581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11582     return 0;
11583   }
11584   {
11585     try {
11586       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11587     } catch (std::out_of_range& e) {
11588       {
11589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11590       };
11591     } catch (std::exception& e) {
11592       {
11593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11594       };
11595     } catch (Dali::DaliException e) {
11596       {
11597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11598       };
11599     } catch (...) {
11600       {
11601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11602       };
11603     }
11604   }
11605
11606   jresult = result;
11607   return jresult;
11608 }
11609
11610
11611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11612   unsigned int jresult ;
11613   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11614   Dali::Quaternion *arg2 = 0 ;
11615   bool result;
11616
11617   arg1 = (Dali::Quaternion *)jarg1;
11618   arg2 = (Dali::Quaternion *)jarg2;
11619   if (!arg2) {
11620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11621     return 0;
11622   }
11623   {
11624     try {
11625       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11626     } catch (std::out_of_range& e) {
11627       {
11628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11629       };
11630     } catch (std::exception& e) {
11631       {
11632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11633       };
11634     } catch (Dali::DaliException e) {
11635       {
11636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11637       };
11638     } catch (...) {
11639       {
11640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11641       };
11642     }
11643   }
11644
11645   jresult = result;
11646   return jresult;
11647 }
11648
11649
11650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11651   float jresult ;
11652   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11653   float result;
11654
11655   arg1 = (Dali::Quaternion *)jarg1;
11656   {
11657     try {
11658       result = (float)((Dali::Quaternion const *)arg1)->Length();
11659     } catch (std::out_of_range& e) {
11660       {
11661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11662       };
11663     } catch (std::exception& e) {
11664       {
11665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11666       };
11667     } catch (Dali::DaliException e) {
11668       {
11669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11670       };
11671     } catch (...) {
11672       {
11673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11674       };
11675     }
11676   }
11677
11678   jresult = result;
11679   return jresult;
11680 }
11681
11682
11683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11684   float jresult ;
11685   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11686   float result;
11687
11688   arg1 = (Dali::Quaternion *)jarg1;
11689   {
11690     try {
11691       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11692     } catch (std::out_of_range& e) {
11693       {
11694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11695       };
11696     } catch (std::exception& e) {
11697       {
11698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11699       };
11700     } catch (Dali::DaliException e) {
11701       {
11702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11703       };
11704     } catch (...) {
11705       {
11706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11707       };
11708     }
11709   }
11710
11711   jresult = result;
11712   return jresult;
11713 }
11714
11715
11716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11717   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11718
11719   arg1 = (Dali::Quaternion *)jarg1;
11720   {
11721     try {
11722       (arg1)->Normalize();
11723     } catch (std::out_of_range& e) {
11724       {
11725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11726       };
11727     } catch (std::exception& e) {
11728       {
11729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11730       };
11731     } catch (Dali::DaliException e) {
11732       {
11733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11734       };
11735     } catch (...) {
11736       {
11737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11738       };
11739     }
11740   }
11741
11742 }
11743
11744
11745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11746   void * jresult ;
11747   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11748   Dali::Quaternion result;
11749
11750   arg1 = (Dali::Quaternion *)jarg1;
11751   {
11752     try {
11753       result = ((Dali::Quaternion const *)arg1)->Normalized();
11754     } catch (std::out_of_range& e) {
11755       {
11756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11757       };
11758     } catch (std::exception& e) {
11759       {
11760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11761       };
11762     } catch (Dali::DaliException e) {
11763       {
11764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11765       };
11766     } catch (...) {
11767       {
11768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11769       };
11770     }
11771   }
11772
11773   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11774   return jresult;
11775 }
11776
11777
11778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11779   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11780
11781   arg1 = (Dali::Quaternion *)jarg1;
11782   {
11783     try {
11784       (arg1)->Conjugate();
11785     } catch (std::out_of_range& e) {
11786       {
11787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11788       };
11789     } catch (std::exception& e) {
11790       {
11791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11792       };
11793     } catch (Dali::DaliException e) {
11794       {
11795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11796       };
11797     } catch (...) {
11798       {
11799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11800       };
11801     }
11802   }
11803
11804 }
11805
11806
11807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11808   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11809
11810   arg1 = (Dali::Quaternion *)jarg1;
11811   {
11812     try {
11813       (arg1)->Invert();
11814     } catch (std::out_of_range& e) {
11815       {
11816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11817       };
11818     } catch (std::exception& e) {
11819       {
11820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11821       };
11822     } catch (Dali::DaliException e) {
11823       {
11824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11825       };
11826     } catch (...) {
11827       {
11828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11829       };
11830     }
11831   }
11832
11833 }
11834
11835
11836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11837   void * jresult ;
11838   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11839   Dali::Quaternion result;
11840
11841   arg1 = (Dali::Quaternion *)jarg1;
11842   {
11843     try {
11844       result = ((Dali::Quaternion const *)arg1)->Log();
11845     } catch (std::out_of_range& e) {
11846       {
11847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11848       };
11849     } catch (std::exception& e) {
11850       {
11851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11852       };
11853     } catch (Dali::DaliException e) {
11854       {
11855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11856       };
11857     } catch (...) {
11858       {
11859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11860       };
11861     }
11862   }
11863
11864   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11865   return jresult;
11866 }
11867
11868
11869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11870   void * jresult ;
11871   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11872   Dali::Quaternion result;
11873
11874   arg1 = (Dali::Quaternion *)jarg1;
11875   {
11876     try {
11877       result = ((Dali::Quaternion const *)arg1)->Exp();
11878     } catch (std::out_of_range& e) {
11879       {
11880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11881       };
11882     } catch (std::exception& e) {
11883       {
11884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11885       };
11886     } catch (Dali::DaliException e) {
11887       {
11888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11889       };
11890     } catch (...) {
11891       {
11892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11893       };
11894     }
11895   }
11896
11897   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11898   return jresult;
11899 }
11900
11901
11902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11903   float jresult ;
11904   Dali::Quaternion *arg1 = 0 ;
11905   Dali::Quaternion *arg2 = 0 ;
11906   float result;
11907
11908   arg1 = (Dali::Quaternion *)jarg1;
11909   if (!arg1) {
11910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11911     return 0;
11912   }
11913   arg2 = (Dali::Quaternion *)jarg2;
11914   if (!arg2) {
11915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11916     return 0;
11917   }
11918   {
11919     try {
11920       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11921     } catch (std::out_of_range& e) {
11922       {
11923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (std::exception& e) {
11926       {
11927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11928       };
11929     } catch (Dali::DaliException e) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11932       };
11933     } catch (...) {
11934       {
11935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11936       };
11937     }
11938   }
11939
11940   jresult = result;
11941   return jresult;
11942 }
11943
11944
11945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11946   void * jresult ;
11947   Dali::Quaternion *arg1 = 0 ;
11948   Dali::Quaternion *arg2 = 0 ;
11949   float arg3 ;
11950   Dali::Quaternion result;
11951
11952   arg1 = (Dali::Quaternion *)jarg1;
11953   if (!arg1) {
11954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11955     return 0;
11956   }
11957   arg2 = (Dali::Quaternion *)jarg2;
11958   if (!arg2) {
11959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11960     return 0;
11961   }
11962   arg3 = (float)jarg3;
11963   {
11964     try {
11965       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11966     } catch (std::out_of_range& e) {
11967       {
11968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11969       };
11970     } catch (std::exception& e) {
11971       {
11972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11973       };
11974     } catch (Dali::DaliException e) {
11975       {
11976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11977       };
11978     } catch (...) {
11979       {
11980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11981       };
11982     }
11983   }
11984
11985   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11986   return jresult;
11987 }
11988
11989
11990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11991   void * jresult ;
11992   Dali::Quaternion *arg1 = 0 ;
11993   Dali::Quaternion *arg2 = 0 ;
11994   float arg3 ;
11995   Dali::Quaternion result;
11996
11997   arg1 = (Dali::Quaternion *)jarg1;
11998   if (!arg1) {
11999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12000     return 0;
12001   }
12002   arg2 = (Dali::Quaternion *)jarg2;
12003   if (!arg2) {
12004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12005     return 0;
12006   }
12007   arg3 = (float)jarg3;
12008   {
12009     try {
12010       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12011     } catch (std::out_of_range& e) {
12012       {
12013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12014       };
12015     } catch (std::exception& e) {
12016       {
12017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12018       };
12019     } catch (Dali::DaliException e) {
12020       {
12021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12022       };
12023     } catch (...) {
12024       {
12025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12026       };
12027     }
12028   }
12029
12030   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12031   return jresult;
12032 }
12033
12034
12035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12036   void * jresult ;
12037   Dali::Quaternion *arg1 = 0 ;
12038   Dali::Quaternion *arg2 = 0 ;
12039   float arg3 ;
12040   Dali::Quaternion result;
12041
12042   arg1 = (Dali::Quaternion *)jarg1;
12043   if (!arg1) {
12044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12045     return 0;
12046   }
12047   arg2 = (Dali::Quaternion *)jarg2;
12048   if (!arg2) {
12049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12050     return 0;
12051   }
12052   arg3 = (float)jarg3;
12053   {
12054     try {
12055       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12056     } catch (std::out_of_range& e) {
12057       {
12058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12059       };
12060     } catch (std::exception& e) {
12061       {
12062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12063       };
12064     } catch (Dali::DaliException e) {
12065       {
12066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12067       };
12068     } catch (...) {
12069       {
12070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12071       };
12072     }
12073   }
12074
12075   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12076   return jresult;
12077 }
12078
12079
12080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12081   void * jresult ;
12082   Dali::Quaternion *arg1 = 0 ;
12083   Dali::Quaternion *arg2 = 0 ;
12084   Dali::Quaternion *arg3 = 0 ;
12085   Dali::Quaternion *arg4 = 0 ;
12086   float arg5 ;
12087   Dali::Quaternion result;
12088
12089   arg1 = (Dali::Quaternion *)jarg1;
12090   if (!arg1) {
12091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12092     return 0;
12093   }
12094   arg2 = (Dali::Quaternion *)jarg2;
12095   if (!arg2) {
12096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12097     return 0;
12098   }
12099   arg3 = (Dali::Quaternion *)jarg3;
12100   if (!arg3) {
12101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12102     return 0;
12103   }
12104   arg4 = (Dali::Quaternion *)jarg4;
12105   if (!arg4) {
12106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12107     return 0;
12108   }
12109   arg5 = (float)jarg5;
12110   {
12111     try {
12112       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12113     } catch (std::out_of_range& e) {
12114       {
12115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12116       };
12117     } catch (std::exception& e) {
12118       {
12119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12120       };
12121     } catch (Dali::DaliException e) {
12122       {
12123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12124       };
12125     } catch (...) {
12126       {
12127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12128       };
12129     }
12130   }
12131
12132   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12133   return jresult;
12134 }
12135
12136
12137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12138   float jresult ;
12139   Dali::Quaternion *arg1 = 0 ;
12140   Dali::Quaternion *arg2 = 0 ;
12141   float result;
12142
12143   arg1 = (Dali::Quaternion *)jarg1;
12144   if (!arg1) {
12145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12146     return 0;
12147   }
12148   arg2 = (Dali::Quaternion *)jarg2;
12149   if (!arg2) {
12150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12151     return 0;
12152   }
12153   {
12154     try {
12155       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12156     } catch (std::out_of_range& e) {
12157       {
12158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12159       };
12160     } catch (std::exception& e) {
12161       {
12162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12163       };
12164     } catch (Dali::DaliException e) {
12165       {
12166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12167       };
12168     } catch (...) {
12169       {
12170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12171       };
12172     }
12173   }
12174
12175   jresult = result;
12176   return jresult;
12177 }
12178
12179
12180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12181   void * jresult ;
12182   Dali::Matrix *result = 0 ;
12183
12184   {
12185     try {
12186       result = (Dali::Matrix *)new Dali::Matrix();
12187     } catch (std::out_of_range& e) {
12188       {
12189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12190       };
12191     } catch (std::exception& e) {
12192       {
12193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12194       };
12195     } catch (Dali::DaliException e) {
12196       {
12197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12198       };
12199     } catch (...) {
12200       {
12201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12202       };
12203     }
12204   }
12205
12206   jresult = (void *)result;
12207   return jresult;
12208 }
12209
12210
12211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12212   void * jresult ;
12213   bool arg1 ;
12214   Dali::Matrix *result = 0 ;
12215
12216   arg1 = jarg1 ? true : false;
12217   {
12218     try {
12219       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12220     } catch (std::out_of_range& e) {
12221       {
12222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12223       };
12224     } catch (std::exception& e) {
12225       {
12226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12227       };
12228     } catch (Dali::DaliException e) {
12229       {
12230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12231       };
12232     } catch (...) {
12233       {
12234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12235       };
12236     }
12237   }
12238
12239   jresult = (void *)result;
12240   return jresult;
12241 }
12242
12243
12244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12245   void * jresult ;
12246   float *arg1 = (float *) 0 ;
12247   Dali::Matrix *result = 0 ;
12248
12249   arg1 = jarg1;
12250   {
12251     try {
12252       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12253     } catch (std::out_of_range& e) {
12254       {
12255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12256       };
12257     } catch (std::exception& e) {
12258       {
12259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12260       };
12261     } catch (Dali::DaliException e) {
12262       {
12263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12264       };
12265     } catch (...) {
12266       {
12267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12268       };
12269     }
12270   }
12271
12272   jresult = (void *)result;
12273
12274
12275   return jresult;
12276 }
12277
12278
12279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12280   void * jresult ;
12281   Dali::Quaternion *arg1 = 0 ;
12282   Dali::Matrix *result = 0 ;
12283
12284   arg1 = (Dali::Quaternion *)jarg1;
12285   if (!arg1) {
12286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12287     return 0;
12288   }
12289   {
12290     try {
12291       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12292     } catch (std::out_of_range& e) {
12293       {
12294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12295       };
12296     } catch (std::exception& e) {
12297       {
12298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12299       };
12300     } catch (Dali::DaliException e) {
12301       {
12302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12303       };
12304     } catch (...) {
12305       {
12306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12307       };
12308     }
12309   }
12310
12311   jresult = (void *)result;
12312   return jresult;
12313 }
12314
12315
12316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12317   void * jresult ;
12318   Dali::Matrix *arg1 = 0 ;
12319   Dali::Matrix *result = 0 ;
12320
12321   arg1 = (Dali::Matrix *)jarg1;
12322   if (!arg1) {
12323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12324     return 0;
12325   }
12326   {
12327     try {
12328       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12329     } catch (std::out_of_range& e) {
12330       {
12331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12332       };
12333     } catch (std::exception& e) {
12334       {
12335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12336       };
12337     } catch (Dali::DaliException e) {
12338       {
12339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12340       };
12341     } catch (...) {
12342       {
12343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12344       };
12345     }
12346   }
12347
12348   jresult = (void *)result;
12349   return jresult;
12350 }
12351
12352
12353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12354   void * jresult ;
12355   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12356   Dali::Matrix *arg2 = 0 ;
12357   Dali::Matrix *result = 0 ;
12358
12359   arg1 = (Dali::Matrix *)jarg1;
12360   arg2 = (Dali::Matrix *)jarg2;
12361   if (!arg2) {
12362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12363     return 0;
12364   }
12365   {
12366     try {
12367       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12368     } catch (std::out_of_range& e) {
12369       {
12370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12371       };
12372     } catch (std::exception& e) {
12373       {
12374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12375       };
12376     } catch (Dali::DaliException e) {
12377       {
12378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12379       };
12380     } catch (...) {
12381       {
12382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12383       };
12384     }
12385   }
12386
12387   jresult = (void *)result;
12388   return jresult;
12389 }
12390
12391
12392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12393   void * jresult ;
12394   Dali::Matrix *result = 0 ;
12395
12396   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12397   jresult = (void *)result;
12398   return jresult;
12399 }
12400
12401
12402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12403   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12404
12405   arg1 = (Dali::Matrix *)jarg1;
12406   {
12407     try {
12408       (arg1)->SetIdentity();
12409     } catch (std::out_of_range& e) {
12410       {
12411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12412       };
12413     } catch (std::exception& e) {
12414       {
12415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12416       };
12417     } catch (Dali::DaliException e) {
12418       {
12419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12420       };
12421     } catch (...) {
12422       {
12423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12424       };
12425     }
12426   }
12427
12428 }
12429
12430
12431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12432   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12433   Dali::Vector3 *arg2 = 0 ;
12434
12435   arg1 = (Dali::Matrix *)jarg1;
12436   arg2 = (Dali::Vector3 *)jarg2;
12437   if (!arg2) {
12438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12439     return ;
12440   }
12441   {
12442     try {
12443       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12444     } catch (std::out_of_range& e) {
12445       {
12446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12447       };
12448     } catch (std::exception& e) {
12449       {
12450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12451       };
12452     } catch (Dali::DaliException e) {
12453       {
12454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12455       };
12456     } catch (...) {
12457       {
12458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12459       };
12460     }
12461   }
12462
12463 }
12464
12465
12466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12467   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12468   Dali::Matrix *arg2 = 0 ;
12469
12470   arg1 = (Dali::Matrix *)jarg1;
12471   arg2 = (Dali::Matrix *)jarg2;
12472   if (!arg2) {
12473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12474     return ;
12475   }
12476   {
12477     try {
12478       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12479     } catch (std::out_of_range& e) {
12480       {
12481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12482       };
12483     } catch (std::exception& e) {
12484       {
12485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12486       };
12487     } catch (Dali::DaliException e) {
12488       {
12489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12490       };
12491     } catch (...) {
12492       {
12493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12494       };
12495     }
12496   }
12497
12498 }
12499
12500
12501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12502   unsigned int jresult ;
12503   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12504   bool result;
12505
12506   arg1 = (Dali::Matrix *)jarg1;
12507   {
12508     try {
12509       result = (bool)(arg1)->Invert();
12510     } catch (std::out_of_range& e) {
12511       {
12512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12513       };
12514     } catch (std::exception& e) {
12515       {
12516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12517       };
12518     } catch (Dali::DaliException e) {
12519       {
12520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12521       };
12522     } catch (...) {
12523       {
12524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12525       };
12526     }
12527   }
12528
12529   jresult = result;
12530   return jresult;
12531 }
12532
12533
12534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12535   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12536
12537   arg1 = (Dali::Matrix *)jarg1;
12538   {
12539     try {
12540       (arg1)->Transpose();
12541     } catch (std::out_of_range& e) {
12542       {
12543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12544       };
12545     } catch (std::exception& e) {
12546       {
12547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12548       };
12549     } catch (Dali::DaliException e) {
12550       {
12551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12552       };
12553     } catch (...) {
12554       {
12555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12556       };
12557     }
12558   }
12559
12560 }
12561
12562
12563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12564   void * jresult ;
12565   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12566   Dali::Vector3 result;
12567
12568   arg1 = (Dali::Matrix *)jarg1;
12569   {
12570     try {
12571       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12572     } catch (std::out_of_range& e) {
12573       {
12574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12575       };
12576     } catch (std::exception& e) {
12577       {
12578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12579       };
12580     } catch (Dali::DaliException e) {
12581       {
12582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12583       };
12584     } catch (...) {
12585       {
12586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12587       };
12588     }
12589   }
12590
12591   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12592   return jresult;
12593 }
12594
12595
12596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12597   void * jresult ;
12598   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12599   Dali::Vector3 result;
12600
12601   arg1 = (Dali::Matrix *)jarg1;
12602   {
12603     try {
12604       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12605     } catch (std::out_of_range& e) {
12606       {
12607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12608       };
12609     } catch (std::exception& e) {
12610       {
12611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12612       };
12613     } catch (Dali::DaliException e) {
12614       {
12615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12616       };
12617     } catch (...) {
12618       {
12619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12620       };
12621     }
12622   }
12623
12624   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12625   return jresult;
12626 }
12627
12628
12629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12630   void * jresult ;
12631   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12632   Dali::Vector3 result;
12633
12634   arg1 = (Dali::Matrix *)jarg1;
12635   {
12636     try {
12637       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12638     } catch (std::out_of_range& e) {
12639       {
12640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12641       };
12642     } catch (std::exception& e) {
12643       {
12644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12645       };
12646     } catch (Dali::DaliException e) {
12647       {
12648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12649       };
12650     } catch (...) {
12651       {
12652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12653       };
12654     }
12655   }
12656
12657   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12658   return jresult;
12659 }
12660
12661
12662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12663   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12664   Dali::Vector3 *arg2 = 0 ;
12665
12666   arg1 = (Dali::Matrix *)jarg1;
12667   arg2 = (Dali::Vector3 *)jarg2;
12668   if (!arg2) {
12669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12670     return ;
12671   }
12672   {
12673     try {
12674       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12675     } catch (std::out_of_range& e) {
12676       {
12677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12678       };
12679     } catch (std::exception& e) {
12680       {
12681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12682       };
12683     } catch (Dali::DaliException e) {
12684       {
12685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12686       };
12687     } catch (...) {
12688       {
12689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12690       };
12691     }
12692   }
12693
12694 }
12695
12696
12697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12698   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12699   Dali::Vector3 *arg2 = 0 ;
12700
12701   arg1 = (Dali::Matrix *)jarg1;
12702   arg2 = (Dali::Vector3 *)jarg2;
12703   if (!arg2) {
12704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12705     return ;
12706   }
12707   {
12708     try {
12709       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12710     } catch (std::out_of_range& e) {
12711       {
12712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12713       };
12714     } catch (std::exception& e) {
12715       {
12716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12717       };
12718     } catch (Dali::DaliException e) {
12719       {
12720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12721       };
12722     } catch (...) {
12723       {
12724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12725       };
12726     }
12727   }
12728
12729 }
12730
12731
12732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12733   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12734   Dali::Vector3 *arg2 = 0 ;
12735
12736   arg1 = (Dali::Matrix *)jarg1;
12737   arg2 = (Dali::Vector3 *)jarg2;
12738   if (!arg2) {
12739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12740     return ;
12741   }
12742   {
12743     try {
12744       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12745     } catch (std::out_of_range& e) {
12746       {
12747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12748       };
12749     } catch (std::exception& e) {
12750       {
12751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12752       };
12753     } catch (Dali::DaliException e) {
12754       {
12755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12756       };
12757     } catch (...) {
12758       {
12759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12760       };
12761     }
12762   }
12763
12764 }
12765
12766
12767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12768   void * jresult ;
12769   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12770   Dali::Vector4 *result = 0 ;
12771
12772   arg1 = (Dali::Matrix *)jarg1;
12773   {
12774     try {
12775       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12776     } catch (std::out_of_range& e) {
12777       {
12778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12779       };
12780     } catch (std::exception& e) {
12781       {
12782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12783       };
12784     } catch (Dali::DaliException e) {
12785       {
12786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12787       };
12788     } catch (...) {
12789       {
12790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12791       };
12792     }
12793   }
12794
12795   jresult = (void *)result;
12796   return jresult;
12797 }
12798
12799
12800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12801   void * jresult ;
12802   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12803   Dali::Vector3 *result = 0 ;
12804
12805   arg1 = (Dali::Matrix *)jarg1;
12806   {
12807     try {
12808       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12809     } catch (std::out_of_range& e) {
12810       {
12811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12812       };
12813     } catch (std::exception& e) {
12814       {
12815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12816       };
12817     } catch (Dali::DaliException e) {
12818       {
12819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12820       };
12821     } catch (...) {
12822       {
12823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12824       };
12825     }
12826   }
12827
12828   jresult = (void *)result;
12829   return jresult;
12830 }
12831
12832
12833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12834   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12835   Dali::Vector4 *arg2 = 0 ;
12836
12837   arg1 = (Dali::Matrix *)jarg1;
12838   arg2 = (Dali::Vector4 *)jarg2;
12839   if (!arg2) {
12840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12841     return ;
12842   }
12843   {
12844     try {
12845       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12846     } catch (std::out_of_range& e) {
12847       {
12848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12849       };
12850     } catch (std::exception& e) {
12851       {
12852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12853       };
12854     } catch (Dali::DaliException e) {
12855       {
12856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12857       };
12858     } catch (...) {
12859       {
12860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12861       };
12862     }
12863   }
12864
12865 }
12866
12867
12868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12869   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12870   Dali::Vector3 *arg2 = 0 ;
12871
12872   arg1 = (Dali::Matrix *)jarg1;
12873   arg2 = (Dali::Vector3 *)jarg2;
12874   if (!arg2) {
12875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12876     return ;
12877   }
12878   {
12879     try {
12880       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12881     } catch (std::out_of_range& e) {
12882       {
12883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12884       };
12885     } catch (std::exception& e) {
12886       {
12887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12888       };
12889     } catch (Dali::DaliException e) {
12890       {
12891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12892       };
12893     } catch (...) {
12894       {
12895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12896       };
12897     }
12898   }
12899
12900 }
12901
12902
12903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12904   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12905
12906   arg1 = (Dali::Matrix *)jarg1;
12907   {
12908     try {
12909       (arg1)->OrthoNormalize();
12910     } catch (std::out_of_range& e) {
12911       {
12912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12913       };
12914     } catch (std::exception& e) {
12915       {
12916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12917       };
12918     } catch (Dali::DaliException e) {
12919       {
12920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12921       };
12922     } catch (...) {
12923       {
12924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12925       };
12926     }
12927   }
12928
12929 }
12930
12931
12932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12933   void * jresult ;
12934   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12935   float *result = 0 ;
12936
12937   arg1 = (Dali::Matrix *)jarg1;
12938   {
12939     try {
12940       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12941     } catch (std::out_of_range& e) {
12942       {
12943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12944       };
12945     } catch (std::exception& e) {
12946       {
12947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12948       };
12949     } catch (Dali::DaliException e) {
12950       {
12951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12952       };
12953     } catch (...) {
12954       {
12955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12956       };
12957     }
12958   }
12959
12960   jresult = (void *)result;
12961   return jresult;
12962 }
12963
12964
12965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12966   Dali::Matrix *arg1 = 0 ;
12967   Dali::Matrix *arg2 = 0 ;
12968   Dali::Matrix *arg3 = 0 ;
12969
12970   arg1 = (Dali::Matrix *)jarg1;
12971   if (!arg1) {
12972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12973     return ;
12974   }
12975   arg2 = (Dali::Matrix *)jarg2;
12976   if (!arg2) {
12977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12978     return ;
12979   }
12980   arg3 = (Dali::Matrix *)jarg3;
12981   if (!arg3) {
12982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12983     return ;
12984   }
12985   {
12986     try {
12987       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12988     } catch (std::out_of_range& e) {
12989       {
12990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12991       };
12992     } catch (std::exception& e) {
12993       {
12994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12995       };
12996     } catch (Dali::DaliException e) {
12997       {
12998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12999       };
13000     } catch (...) {
13001       {
13002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13003       };
13004     }
13005   }
13006
13007 }
13008
13009
13010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13011   Dali::Matrix *arg1 = 0 ;
13012   Dali::Matrix *arg2 = 0 ;
13013   Dali::Quaternion *arg3 = 0 ;
13014
13015   arg1 = (Dali::Matrix *)jarg1;
13016   if (!arg1) {
13017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13018     return ;
13019   }
13020   arg2 = (Dali::Matrix *)jarg2;
13021   if (!arg2) {
13022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13023     return ;
13024   }
13025   arg3 = (Dali::Quaternion *)jarg3;
13026   if (!arg3) {
13027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13028     return ;
13029   }
13030   {
13031     try {
13032       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13033     } catch (std::out_of_range& e) {
13034       {
13035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13036       };
13037     } catch (std::exception& e) {
13038       {
13039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13040       };
13041     } catch (Dali::DaliException e) {
13042       {
13043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13044       };
13045     } catch (...) {
13046       {
13047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13048       };
13049     }
13050   }
13051
13052 }
13053
13054
13055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13056   void * jresult ;
13057   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13058   Dali::Vector4 *arg2 = 0 ;
13059   Dali::Vector4 result;
13060
13061   arg1 = (Dali::Matrix *)jarg1;
13062   arg2 = (Dali::Vector4 *)jarg2;
13063   if (!arg2) {
13064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13065     return 0;
13066   }
13067   {
13068     try {
13069       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13070     } catch (std::out_of_range& e) {
13071       {
13072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13073       };
13074     } catch (std::exception& e) {
13075       {
13076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13077       };
13078     } catch (Dali::DaliException e) {
13079       {
13080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13081       };
13082     } catch (...) {
13083       {
13084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13085       };
13086     }
13087   }
13088
13089   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13090   return jresult;
13091 }
13092
13093
13094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13095   unsigned int jresult ;
13096   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13097   Dali::Matrix *arg2 = 0 ;
13098   bool result;
13099
13100   arg1 = (Dali::Matrix *)jarg1;
13101   arg2 = (Dali::Matrix *)jarg2;
13102   if (!arg2) {
13103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13104     return 0;
13105   }
13106   {
13107     try {
13108       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13109     } catch (std::out_of_range& e) {
13110       {
13111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13112       };
13113     } catch (std::exception& e) {
13114       {
13115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13116       };
13117     } catch (Dali::DaliException e) {
13118       {
13119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13120       };
13121     } catch (...) {
13122       {
13123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13124       };
13125     }
13126   }
13127
13128   jresult = result;
13129   return jresult;
13130 }
13131
13132
13133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13134   unsigned int jresult ;
13135   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13136   Dali::Matrix *arg2 = 0 ;
13137   bool result;
13138
13139   arg1 = (Dali::Matrix *)jarg1;
13140   arg2 = (Dali::Matrix *)jarg2;
13141   if (!arg2) {
13142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13143     return 0;
13144   }
13145   {
13146     try {
13147       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13148     } catch (std::out_of_range& e) {
13149       {
13150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13151       };
13152     } catch (std::exception& e) {
13153       {
13154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13155       };
13156     } catch (Dali::DaliException e) {
13157       {
13158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13159       };
13160     } catch (...) {
13161       {
13162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13163       };
13164     }
13165   }
13166
13167   jresult = result;
13168   return jresult;
13169 }
13170
13171
13172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13173   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13174   Dali::Vector3 *arg2 = 0 ;
13175   Dali::Quaternion *arg3 = 0 ;
13176   Dali::Vector3 *arg4 = 0 ;
13177
13178   arg1 = (Dali::Matrix *)jarg1;
13179   arg2 = (Dali::Vector3 *)jarg2;
13180   if (!arg2) {
13181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13182     return ;
13183   }
13184   arg3 = (Dali::Quaternion *)jarg3;
13185   if (!arg3) {
13186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13187     return ;
13188   }
13189   arg4 = (Dali::Vector3 *)jarg4;
13190   if (!arg4) {
13191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13192     return ;
13193   }
13194   {
13195     try {
13196       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13197     } catch (std::out_of_range& e) {
13198       {
13199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13200       };
13201     } catch (std::exception& e) {
13202       {
13203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13204       };
13205     } catch (Dali::DaliException e) {
13206       {
13207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13208       };
13209     } catch (...) {
13210       {
13211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13212       };
13213     }
13214   }
13215
13216 }
13217
13218
13219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13220   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13221   Dali::Vector3 *arg2 = 0 ;
13222   Dali::Quaternion *arg3 = 0 ;
13223   Dali::Vector3 *arg4 = 0 ;
13224
13225   arg1 = (Dali::Matrix *)jarg1;
13226   arg2 = (Dali::Vector3 *)jarg2;
13227   if (!arg2) {
13228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13229     return ;
13230   }
13231   arg3 = (Dali::Quaternion *)jarg3;
13232   if (!arg3) {
13233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13234     return ;
13235   }
13236   arg4 = (Dali::Vector3 *)jarg4;
13237   if (!arg4) {
13238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13239     return ;
13240   }
13241   {
13242     try {
13243       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13244     } catch (std::out_of_range& e) {
13245       {
13246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13247       };
13248     } catch (std::exception& e) {
13249       {
13250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13251       };
13252     } catch (Dali::DaliException e) {
13253       {
13254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13255       };
13256     } catch (...) {
13257       {
13258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13259       };
13260     }
13261   }
13262
13263 }
13264
13265
13266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13267   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13268   Dali::Vector3 *arg2 = 0 ;
13269   Dali::Vector3 *arg3 = 0 ;
13270   Dali::Vector3 *arg4 = 0 ;
13271   Dali::Vector3 *arg5 = 0 ;
13272
13273   arg1 = (Dali::Matrix *)jarg1;
13274   arg2 = (Dali::Vector3 *)jarg2;
13275   if (!arg2) {
13276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13277     return ;
13278   }
13279   arg3 = (Dali::Vector3 *)jarg3;
13280   if (!arg3) {
13281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13282     return ;
13283   }
13284   arg4 = (Dali::Vector3 *)jarg4;
13285   if (!arg4) {
13286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13287     return ;
13288   }
13289   arg5 = (Dali::Vector3 *)jarg5;
13290   if (!arg5) {
13291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13292     return ;
13293   }
13294   {
13295     try {
13296       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13297     } catch (std::out_of_range& e) {
13298       {
13299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13300       };
13301     } catch (std::exception& e) {
13302       {
13303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13304       };
13305     } catch (Dali::DaliException e) {
13306       {
13307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13308       };
13309     } catch (...) {
13310       {
13311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13312       };
13313     }
13314   }
13315
13316 }
13317
13318
13319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13320   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13321   Dali::Vector3 *arg2 = 0 ;
13322   Dali::Quaternion *arg3 = 0 ;
13323   Dali::Vector3 *arg4 = 0 ;
13324
13325   arg1 = (Dali::Matrix *)jarg1;
13326   arg2 = (Dali::Vector3 *)jarg2;
13327   if (!arg2) {
13328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13329     return ;
13330   }
13331   arg3 = (Dali::Quaternion *)jarg3;
13332   if (!arg3) {
13333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13334     return ;
13335   }
13336   arg4 = (Dali::Vector3 *)jarg4;
13337   if (!arg4) {
13338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13339     return ;
13340   }
13341   {
13342     try {
13343       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13344     } catch (std::out_of_range& e) {
13345       {
13346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13347       };
13348     } catch (std::exception& e) {
13349       {
13350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13351       };
13352     } catch (Dali::DaliException e) {
13353       {
13354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13355       };
13356     } catch (...) {
13357       {
13358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13359       };
13360     }
13361   }
13362
13363 }
13364
13365
13366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13367   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13368
13369   arg1 = (Dali::Matrix *)jarg1;
13370   {
13371     try {
13372       delete arg1;
13373     } catch (std::out_of_range& e) {
13374       {
13375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13376       };
13377     } catch (std::exception& e) {
13378       {
13379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13380       };
13381     } catch (Dali::DaliException e) {
13382       {
13383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13384       };
13385     } catch (...) {
13386       {
13387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13388       };
13389     }
13390   }
13391
13392 }
13393
13394
13395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13396   void * jresult ;
13397   Dali::Matrix3 *result = 0 ;
13398
13399   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13400   jresult = (void *)result;
13401   return jresult;
13402 }
13403
13404
13405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13406   void * jresult ;
13407   Dali::Matrix3 *result = 0 ;
13408
13409   {
13410     try {
13411       result = (Dali::Matrix3 *)new Dali::Matrix3();
13412     } catch (std::out_of_range& e) {
13413       {
13414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13415       };
13416     } catch (std::exception& e) {
13417       {
13418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13419       };
13420     } catch (Dali::DaliException e) {
13421       {
13422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13423       };
13424     } catch (...) {
13425       {
13426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13427       };
13428     }
13429   }
13430
13431   jresult = (void *)result;
13432   return jresult;
13433 }
13434
13435
13436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13437   void * jresult ;
13438   Dali::Matrix3 *arg1 = 0 ;
13439   Dali::Matrix3 *result = 0 ;
13440
13441   arg1 = (Dali::Matrix3 *)jarg1;
13442   if (!arg1) {
13443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13444     return 0;
13445   }
13446   {
13447     try {
13448       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13449     } catch (std::out_of_range& e) {
13450       {
13451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13452       };
13453     } catch (std::exception& e) {
13454       {
13455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13456       };
13457     } catch (Dali::DaliException e) {
13458       {
13459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13460       };
13461     } catch (...) {
13462       {
13463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13464       };
13465     }
13466   }
13467
13468   jresult = (void *)result;
13469   return jresult;
13470 }
13471
13472
13473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13474   void * jresult ;
13475   Dali::Matrix *arg1 = 0 ;
13476   Dali::Matrix3 *result = 0 ;
13477
13478   arg1 = (Dali::Matrix *)jarg1;
13479   if (!arg1) {
13480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13481     return 0;
13482   }
13483   {
13484     try {
13485       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13486     } catch (std::out_of_range& e) {
13487       {
13488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13489       };
13490     } catch (std::exception& e) {
13491       {
13492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13493       };
13494     } catch (Dali::DaliException e) {
13495       {
13496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13497       };
13498     } catch (...) {
13499       {
13500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13501       };
13502     }
13503   }
13504
13505   jresult = (void *)result;
13506   return jresult;
13507 }
13508
13509
13510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13511   void * jresult ;
13512   float arg1 ;
13513   float arg2 ;
13514   float arg3 ;
13515   float arg4 ;
13516   float arg5 ;
13517   float arg6 ;
13518   float arg7 ;
13519   float arg8 ;
13520   float arg9 ;
13521   Dali::Matrix3 *result = 0 ;
13522
13523   arg1 = (float)jarg1;
13524   arg2 = (float)jarg2;
13525   arg3 = (float)jarg3;
13526   arg4 = (float)jarg4;
13527   arg5 = (float)jarg5;
13528   arg6 = (float)jarg6;
13529   arg7 = (float)jarg7;
13530   arg8 = (float)jarg8;
13531   arg9 = (float)jarg9;
13532   {
13533     try {
13534       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13535     } catch (std::out_of_range& e) {
13536       {
13537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13538       };
13539     } catch (std::exception& e) {
13540       {
13541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13542       };
13543     } catch (Dali::DaliException e) {
13544       {
13545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13546       };
13547     } catch (...) {
13548       {
13549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13550       };
13551     }
13552   }
13553
13554   jresult = (void *)result;
13555   return jresult;
13556 }
13557
13558
13559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13560   void * jresult ;
13561   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13562   Dali::Matrix3 *arg2 = 0 ;
13563   Dali::Matrix3 *result = 0 ;
13564
13565   arg1 = (Dali::Matrix3 *)jarg1;
13566   arg2 = (Dali::Matrix3 *)jarg2;
13567   if (!arg2) {
13568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13569     return 0;
13570   }
13571   {
13572     try {
13573       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13574     } catch (std::out_of_range& e) {
13575       {
13576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13577       };
13578     } catch (std::exception& e) {
13579       {
13580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13581       };
13582     } catch (Dali::DaliException e) {
13583       {
13584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13585       };
13586     } catch (...) {
13587       {
13588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13589       };
13590     }
13591   }
13592
13593   jresult = (void *)result;
13594   return jresult;
13595 }
13596
13597
13598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13599   void * jresult ;
13600   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13601   Dali::Matrix *arg2 = 0 ;
13602   Dali::Matrix3 *result = 0 ;
13603
13604   arg1 = (Dali::Matrix3 *)jarg1;
13605   arg2 = (Dali::Matrix *)jarg2;
13606   if (!arg2) {
13607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13608     return 0;
13609   }
13610   {
13611     try {
13612       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13613     } catch (std::out_of_range& e) {
13614       {
13615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13616       };
13617     } catch (std::exception& e) {
13618       {
13619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13620       };
13621     } catch (Dali::DaliException e) {
13622       {
13623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13624       };
13625     } catch (...) {
13626       {
13627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13628       };
13629     }
13630   }
13631
13632   jresult = (void *)result;
13633   return jresult;
13634 }
13635
13636
13637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13638   unsigned int jresult ;
13639   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13640   Dali::Matrix3 *arg2 = 0 ;
13641   bool result;
13642
13643   arg1 = (Dali::Matrix3 *)jarg1;
13644   arg2 = (Dali::Matrix3 *)jarg2;
13645   if (!arg2) {
13646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13647     return 0;
13648   }
13649   {
13650     try {
13651       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13652     } catch (std::out_of_range& e) {
13653       {
13654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13655       };
13656     } catch (std::exception& e) {
13657       {
13658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13659       };
13660     } catch (Dali::DaliException e) {
13661       {
13662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13663       };
13664     } catch (...) {
13665       {
13666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13667       };
13668     }
13669   }
13670
13671   jresult = result;
13672   return jresult;
13673 }
13674
13675
13676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13677   unsigned int jresult ;
13678   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13679   Dali::Matrix3 *arg2 = 0 ;
13680   bool result;
13681
13682   arg1 = (Dali::Matrix3 *)jarg1;
13683   arg2 = (Dali::Matrix3 *)jarg2;
13684   if (!arg2) {
13685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13686     return 0;
13687   }
13688   {
13689     try {
13690       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13691     } catch (std::out_of_range& e) {
13692       {
13693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13694       };
13695     } catch (std::exception& e) {
13696       {
13697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13698       };
13699     } catch (Dali::DaliException e) {
13700       {
13701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13702       };
13703     } catch (...) {
13704       {
13705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13706       };
13707     }
13708   }
13709
13710   jresult = result;
13711   return jresult;
13712 }
13713
13714
13715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13716   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13717
13718   arg1 = (Dali::Matrix3 *)jarg1;
13719   {
13720     try {
13721       delete arg1;
13722     } catch (std::out_of_range& e) {
13723       {
13724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13725       };
13726     } catch (std::exception& e) {
13727       {
13728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13729       };
13730     } catch (Dali::DaliException e) {
13731       {
13732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13733       };
13734     } catch (...) {
13735       {
13736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13737       };
13738     }
13739   }
13740
13741 }
13742
13743
13744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13745   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13746
13747   arg1 = (Dali::Matrix3 *)jarg1;
13748   {
13749     try {
13750       (arg1)->SetIdentity();
13751     } catch (std::out_of_range& e) {
13752       {
13753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13754       };
13755     } catch (std::exception& e) {
13756       {
13757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13758       };
13759     } catch (Dali::DaliException e) {
13760       {
13761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13762       };
13763     } catch (...) {
13764       {
13765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13766       };
13767     }
13768   }
13769
13770 }
13771
13772
13773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13774   void * jresult ;
13775   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13776   float *result = 0 ;
13777
13778   arg1 = (Dali::Matrix3 *)jarg1;
13779   {
13780     try {
13781       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13782     } catch (std::out_of_range& e) {
13783       {
13784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13785       };
13786     } catch (std::exception& e) {
13787       {
13788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13789       };
13790     } catch (Dali::DaliException e) {
13791       {
13792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13793       };
13794     } catch (...) {
13795       {
13796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13797       };
13798     }
13799   }
13800
13801   jresult = (void *)result;
13802   return jresult;
13803 }
13804
13805
13806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13807   unsigned int jresult ;
13808   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13809   bool result;
13810
13811   arg1 = (Dali::Matrix3 *)jarg1;
13812   {
13813     try {
13814       result = (bool)(arg1)->Invert();
13815     } catch (std::out_of_range& e) {
13816       {
13817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13818       };
13819     } catch (std::exception& e) {
13820       {
13821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13822       };
13823     } catch (Dali::DaliException e) {
13824       {
13825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13826       };
13827     } catch (...) {
13828       {
13829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13830       };
13831     }
13832   }
13833
13834   jresult = result;
13835   return jresult;
13836 }
13837
13838
13839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13840   unsigned int jresult ;
13841   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13842   bool result;
13843
13844   arg1 = (Dali::Matrix3 *)jarg1;
13845   {
13846     try {
13847       result = (bool)(arg1)->Transpose();
13848     } catch (std::out_of_range& e) {
13849       {
13850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13851       };
13852     } catch (std::exception& e) {
13853       {
13854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13855       };
13856     } catch (Dali::DaliException e) {
13857       {
13858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13859       };
13860     } catch (...) {
13861       {
13862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13863       };
13864     }
13865   }
13866
13867   jresult = result;
13868   return jresult;
13869 }
13870
13871
13872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13873   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13874   float arg2 ;
13875
13876   arg1 = (Dali::Matrix3 *)jarg1;
13877   arg2 = (float)jarg2;
13878   {
13879     try {
13880       (arg1)->Scale(arg2);
13881     } catch (std::out_of_range& e) {
13882       {
13883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13884       };
13885     } catch (std::exception& e) {
13886       {
13887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13888       };
13889     } catch (Dali::DaliException e) {
13890       {
13891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13892       };
13893     } catch (...) {
13894       {
13895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13896       };
13897     }
13898   }
13899
13900 }
13901
13902
13903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13904   float jresult ;
13905   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13906   float result;
13907
13908   arg1 = (Dali::Matrix3 *)jarg1;
13909   {
13910     try {
13911       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13912     } catch (std::out_of_range& e) {
13913       {
13914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13915       };
13916     } catch (std::exception& e) {
13917       {
13918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13919       };
13920     } catch (Dali::DaliException e) {
13921       {
13922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13923       };
13924     } catch (...) {
13925       {
13926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13927       };
13928     }
13929   }
13930
13931   jresult = result;
13932   return jresult;
13933 }
13934
13935
13936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13937   unsigned int jresult ;
13938   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13939   bool result;
13940
13941   arg1 = (Dali::Matrix3 *)jarg1;
13942   {
13943     try {
13944       result = (bool)(arg1)->ScaledInverseTranspose();
13945     } catch (std::out_of_range& e) {
13946       {
13947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13948       };
13949     } catch (std::exception& e) {
13950       {
13951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13952       };
13953     } catch (Dali::DaliException e) {
13954       {
13955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13956       };
13957     } catch (...) {
13958       {
13959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13960       };
13961     }
13962   }
13963
13964   jresult = result;
13965   return jresult;
13966 }
13967
13968
13969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13970   Dali::Matrix3 *arg1 = 0 ;
13971   Dali::Matrix3 *arg2 = 0 ;
13972   Dali::Matrix3 *arg3 = 0 ;
13973
13974   arg1 = (Dali::Matrix3 *)jarg1;
13975   if (!arg1) {
13976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13977     return ;
13978   }
13979   arg2 = (Dali::Matrix3 *)jarg2;
13980   if (!arg2) {
13981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13982     return ;
13983   }
13984   arg3 = (Dali::Matrix3 *)jarg3;
13985   if (!arg3) {
13986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13987     return ;
13988   }
13989   {
13990     try {
13991       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13992     } catch (std::out_of_range& e) {
13993       {
13994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13995       };
13996     } catch (std::exception& e) {
13997       {
13998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13999       };
14000     } catch (Dali::DaliException e) {
14001       {
14002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14003       };
14004     } catch (...) {
14005       {
14006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14007       };
14008     }
14009   }
14010
14011 }
14012
14013
14014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14015   float jresult ;
14016   float arg1 ;
14017   float arg2 ;
14018   float result;
14019
14020   arg1 = (float)jarg1;
14021   arg2 = (float)jarg2;
14022   {
14023     try {
14024       result = (float)Dali::Random::Range(arg1,arg2);
14025     } catch (std::out_of_range& e) {
14026       {
14027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14028       };
14029     } catch (std::exception& e) {
14030       {
14031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14032       };
14033     } catch (Dali::DaliException e) {
14034       {
14035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14036       };
14037     } catch (...) {
14038       {
14039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14040       };
14041     }
14042   }
14043
14044   jresult = result;
14045   return jresult;
14046 }
14047
14048
14049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14050   void * jresult ;
14051   Dali::Vector4 result;
14052
14053   {
14054     try {
14055       result = Dali::Random::Axis();
14056     } catch (std::out_of_range& e) {
14057       {
14058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14059       };
14060     } catch (std::exception& e) {
14061       {
14062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14063       };
14064     } catch (Dali::DaliException e) {
14065       {
14066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14067       };
14068     } catch (...) {
14069       {
14070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14071       };
14072     }
14073   }
14074
14075   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14076   return jresult;
14077 }
14078
14079
14080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14081   void * jresult ;
14082   Dali::AngleAxis *result = 0 ;
14083
14084   {
14085     try {
14086       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14087     } catch (std::out_of_range& e) {
14088       {
14089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14090       };
14091     } catch (std::exception& e) {
14092       {
14093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14094       };
14095     } catch (Dali::DaliException e) {
14096       {
14097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14098       };
14099     } catch (...) {
14100       {
14101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14102       };
14103     }
14104   }
14105
14106   jresult = (void *)result;
14107   return jresult;
14108 }
14109
14110
14111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14112   void * jresult ;
14113   Dali::Radian arg1 ;
14114   Dali::Vector3 *arg2 = 0 ;
14115   Dali::Radian *argp1 ;
14116   Dali::AngleAxis *result = 0 ;
14117
14118   argp1 = (Dali::Radian *)jarg1;
14119   if (!argp1) {
14120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14121     return 0;
14122   }
14123   arg1 = *argp1;
14124   arg2 = (Dali::Vector3 *)jarg2;
14125   if (!arg2) {
14126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14127     return 0;
14128   }
14129   {
14130     try {
14131       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14132     } catch (std::out_of_range& e) {
14133       {
14134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14135       };
14136     } catch (std::exception& e) {
14137       {
14138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14139       };
14140     } catch (Dali::DaliException e) {
14141       {
14142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14143       };
14144     } catch (...) {
14145       {
14146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14147       };
14148     }
14149   }
14150
14151   jresult = (void *)result;
14152   return jresult;
14153 }
14154
14155
14156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14157   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14158   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14159
14160   arg1 = (Dali::AngleAxis *)jarg1;
14161   arg2 = (Dali::Radian *)jarg2;
14162   if (arg1) (arg1)->angle = *arg2;
14163 }
14164
14165
14166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14167   void * jresult ;
14168   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14169   Dali::Radian *result = 0 ;
14170
14171   arg1 = (Dali::AngleAxis *)jarg1;
14172   result = (Dali::Radian *)& ((arg1)->angle);
14173   jresult = (void *)result;
14174   return jresult;
14175 }
14176
14177
14178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14179   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14180   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14181
14182   arg1 = (Dali::AngleAxis *)jarg1;
14183   arg2 = (Dali::Vector3 *)jarg2;
14184   if (arg1) (arg1)->axis = *arg2;
14185 }
14186
14187
14188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14189   void * jresult ;
14190   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14191   Dali::Vector3 *result = 0 ;
14192
14193   arg1 = (Dali::AngleAxis *)jarg1;
14194   result = (Dali::Vector3 *)& ((arg1)->axis);
14195   jresult = (void *)result;
14196   return jresult;
14197 }
14198
14199
14200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14201   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14202
14203   arg1 = (Dali::AngleAxis *)jarg1;
14204   {
14205     try {
14206       delete arg1;
14207     } catch (std::out_of_range& e) {
14208       {
14209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14210       };
14211     } catch (std::exception& e) {
14212       {
14213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14214       };
14215     } catch (Dali::DaliException e) {
14216       {
14217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14218       };
14219     } catch (...) {
14220       {
14221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14222       };
14223     }
14224   }
14225
14226 }
14227
14228
14229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14230   unsigned int jresult ;
14231   Dali::AngleAxis *arg1 = 0 ;
14232   Dali::AngleAxis *arg2 = 0 ;
14233   bool result;
14234
14235   arg1 = (Dali::AngleAxis *)jarg1;
14236   if (!arg1) {
14237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14238     return 0;
14239   }
14240   arg2 = (Dali::AngleAxis *)jarg2;
14241   if (!arg2) {
14242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14243     return 0;
14244   }
14245   {
14246     try {
14247       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14248     } catch (std::out_of_range& e) {
14249       {
14250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14251       };
14252     } catch (std::exception& e) {
14253       {
14254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14255       };
14256     } catch (Dali::DaliException e) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14259       };
14260     } catch (...) {
14261       {
14262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14263       };
14264     }
14265   }
14266
14267   jresult = result;
14268   return jresult;
14269 }
14270
14271
14272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14273   unsigned int jresult ;
14274   unsigned int arg1 ;
14275   unsigned int result;
14276
14277   arg1 = (unsigned int)jarg1;
14278   {
14279     try {
14280       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14281     } catch (std::out_of_range& e) {
14282       {
14283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14284       };
14285     } catch (std::exception& e) {
14286       {
14287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14288       };
14289     } catch (Dali::DaliException e) {
14290       {
14291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14292       };
14293     } catch (...) {
14294       {
14295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14296       };
14297     }
14298   }
14299
14300   jresult = result;
14301   return jresult;
14302 }
14303
14304
14305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14306   unsigned int jresult ;
14307   unsigned int arg1 ;
14308   bool result;
14309
14310   arg1 = (unsigned int)jarg1;
14311   {
14312     try {
14313       result = (bool)Dali::IsPowerOfTwo(arg1);
14314     } catch (std::out_of_range& e) {
14315       {
14316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14317       };
14318     } catch (std::exception& e) {
14319       {
14320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14321       };
14322     } catch (Dali::DaliException e) {
14323       {
14324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14325       };
14326     } catch (...) {
14327       {
14328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14329       };
14330     }
14331   }
14332
14333   jresult = result;
14334   return jresult;
14335 }
14336
14337
14338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14339   float jresult ;
14340   float arg1 ;
14341   float arg2 ;
14342   float result;
14343
14344   arg1 = (float)jarg1;
14345   arg2 = (float)jarg2;
14346   {
14347     try {
14348       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14349     } catch (std::out_of_range& e) {
14350       {
14351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14352       };
14353     } catch (std::exception& e) {
14354       {
14355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14356       };
14357     } catch (Dali::DaliException e) {
14358       {
14359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14360       };
14361     } catch (...) {
14362       {
14363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14364       };
14365     }
14366   }
14367
14368   jresult = result;
14369   return jresult;
14370 }
14371
14372
14373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14374   unsigned int jresult ;
14375   float arg1 ;
14376   bool result;
14377
14378   arg1 = (float)jarg1;
14379   {
14380     try {
14381       result = (bool)Dali::EqualsZero(arg1);
14382     } catch (std::out_of_range& e) {
14383       {
14384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14385       };
14386     } catch (std::exception& e) {
14387       {
14388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14389       };
14390     } catch (Dali::DaliException e) {
14391       {
14392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14393       };
14394     } catch (...) {
14395       {
14396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14397       };
14398     }
14399   }
14400
14401   jresult = result;
14402   return jresult;
14403 }
14404
14405
14406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14407   unsigned int jresult ;
14408   float arg1 ;
14409   float arg2 ;
14410   bool result;
14411
14412   arg1 = (float)jarg1;
14413   arg2 = (float)jarg2;
14414   {
14415     try {
14416       result = (bool)Dali::Equals(arg1,arg2);
14417     } catch (std::out_of_range& e) {
14418       {
14419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14420       };
14421     } catch (std::exception& e) {
14422       {
14423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14424       };
14425     } catch (Dali::DaliException e) {
14426       {
14427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14428       };
14429     } catch (...) {
14430       {
14431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14432       };
14433     }
14434   }
14435
14436   jresult = result;
14437   return jresult;
14438 }
14439
14440
14441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14442   unsigned int jresult ;
14443   float arg1 ;
14444   float arg2 ;
14445   float arg3 ;
14446   bool result;
14447
14448   arg1 = (float)jarg1;
14449   arg2 = (float)jarg2;
14450   arg3 = (float)jarg3;
14451   {
14452     try {
14453       result = (bool)Dali::Equals(arg1,arg2,arg3);
14454     } catch (std::out_of_range& e) {
14455       {
14456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14457       };
14458     } catch (std::exception& e) {
14459       {
14460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14461       };
14462     } catch (Dali::DaliException e) {
14463       {
14464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14465       };
14466     } catch (...) {
14467       {
14468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14469       };
14470     }
14471   }
14472
14473   jresult = result;
14474   return jresult;
14475 }
14476
14477
14478 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14479   float jresult ;
14480   float arg1 ;
14481   int arg2 ;
14482   float result;
14483
14484   arg1 = (float)jarg1;
14485   arg2 = (int)jarg2;
14486   {
14487     try {
14488       result = (float)Dali::Round(arg1,arg2);
14489     } catch (std::out_of_range& e) {
14490       {
14491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14492       };
14493     } catch (std::exception& e) {
14494       {
14495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14496       };
14497     } catch (Dali::DaliException e) {
14498       {
14499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14500       };
14501     } catch (...) {
14502       {
14503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14504       };
14505     }
14506   }
14507
14508   jresult = result;
14509   return jresult;
14510 }
14511
14512
14513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14514   float jresult ;
14515   float arg1 ;
14516   float arg2 ;
14517   float arg3 ;
14518   float result;
14519
14520   arg1 = (float)jarg1;
14521   arg2 = (float)jarg2;
14522   arg3 = (float)jarg3;
14523   {
14524     try {
14525       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14526     } catch (std::out_of_range& e) {
14527       {
14528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14529       };
14530     } catch (std::exception& e) {
14531       {
14532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14533       };
14534     } catch (Dali::DaliException e) {
14535       {
14536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14537       };
14538     } catch (...) {
14539       {
14540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14541       };
14542     }
14543   }
14544
14545   jresult = result;
14546   return jresult;
14547 }
14548
14549
14550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14551   float jresult ;
14552   float arg1 ;
14553   float arg2 ;
14554   float arg3 ;
14555   float arg4 ;
14556   float result;
14557
14558   arg1 = (float)jarg1;
14559   arg2 = (float)jarg2;
14560   arg3 = (float)jarg3;
14561   arg4 = (float)jarg4;
14562   {
14563     try {
14564       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14565     } catch (std::out_of_range& e) {
14566       {
14567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14568       };
14569     } catch (std::exception& e) {
14570       {
14571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14572       };
14573     } catch (Dali::DaliException e) {
14574       {
14575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14576       };
14577     } catch (...) {
14578       {
14579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14580       };
14581     }
14582   }
14583
14584   jresult = result;
14585   return jresult;
14586 }
14587
14588
14589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14590   int jresult ;
14591   int result;
14592
14593   result = (int)(int)Dali::Property::INVALID_INDEX;
14594   jresult = result;
14595   return jresult;
14596 }
14597
14598
14599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14600   int jresult ;
14601   int result;
14602
14603   result = (int)(int)Dali::Property::INVALID_KEY;
14604   jresult = result;
14605   return jresult;
14606 }
14607
14608
14609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14610   int jresult ;
14611   int result;
14612
14613   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14614   jresult = result;
14615   return jresult;
14616 }
14617
14618
14619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14620   void * jresult ;
14621   Dali::Handle *arg1 = 0 ;
14622   Dali::Property::Index arg2 ;
14623   Dali::Property *result = 0 ;
14624
14625   arg1 = (Dali::Handle *)jarg1;
14626   if (!arg1) {
14627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14628     return 0;
14629   }
14630   arg2 = (Dali::Property::Index)jarg2;
14631   {
14632     try {
14633       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14634     } catch (std::out_of_range& e) {
14635       {
14636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14637       };
14638     } catch (std::exception& e) {
14639       {
14640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14641       };
14642     } catch (Dali::DaliException e) {
14643       {
14644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14645       };
14646     } catch (...) {
14647       {
14648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14649       };
14650     }
14651   }
14652
14653   jresult = (void *)result;
14654   return jresult;
14655 }
14656
14657
14658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14659   void * jresult ;
14660   Dali::Handle *arg1 = 0 ;
14661   Dali::Property::Index arg2 ;
14662   int arg3 ;
14663   Dali::Property *result = 0 ;
14664
14665   arg1 = (Dali::Handle *)jarg1;
14666   if (!arg1) {
14667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14668     return 0;
14669   }
14670   arg2 = (Dali::Property::Index)jarg2;
14671   arg3 = (int)jarg3;
14672   {
14673     try {
14674       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14675     } catch (std::out_of_range& e) {
14676       {
14677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14678       };
14679     } catch (std::exception& e) {
14680       {
14681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14682       };
14683     } catch (Dali::DaliException e) {
14684       {
14685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14686       };
14687     } catch (...) {
14688       {
14689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14690       };
14691     }
14692   }
14693
14694   jresult = (void *)result;
14695   return jresult;
14696 }
14697
14698
14699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14700   void * jresult ;
14701   Dali::Handle *arg1 = 0 ;
14702   std::string *arg2 = 0 ;
14703   Dali::Property *result = 0 ;
14704
14705   arg1 = (Dali::Handle *)jarg1;
14706   if (!arg1) {
14707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14708     return 0;
14709   }
14710   if (!jarg2) {
14711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14712     return 0;
14713   }
14714   std::string arg2_str(jarg2);
14715   arg2 = &arg2_str;
14716   {
14717     try {
14718       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14719     } catch (std::out_of_range& e) {
14720       {
14721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14722       };
14723     } catch (std::exception& e) {
14724       {
14725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14726       };
14727     } catch (Dali::DaliException e) {
14728       {
14729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14730       };
14731     } catch (...) {
14732       {
14733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14734       };
14735     }
14736   }
14737
14738   jresult = (void *)result;
14739
14740   //argout typemap for const std::string&
14741
14742   return jresult;
14743 }
14744
14745
14746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14747   void * jresult ;
14748   Dali::Handle *arg1 = 0 ;
14749   std::string *arg2 = 0 ;
14750   int arg3 ;
14751   Dali::Property *result = 0 ;
14752
14753   arg1 = (Dali::Handle *)jarg1;
14754   if (!arg1) {
14755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14756     return 0;
14757   }
14758   if (!jarg2) {
14759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14760     return 0;
14761   }
14762   std::string arg2_str(jarg2);
14763   arg2 = &arg2_str;
14764   arg3 = (int)jarg3;
14765   {
14766     try {
14767       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14768     } catch (std::out_of_range& e) {
14769       {
14770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14771       };
14772     } catch (std::exception& e) {
14773       {
14774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14775       };
14776     } catch (Dali::DaliException e) {
14777       {
14778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14779       };
14780     } catch (...) {
14781       {
14782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14783       };
14784     }
14785   }
14786
14787   jresult = (void *)result;
14788
14789   //argout typemap for const std::string&
14790
14791   return jresult;
14792 }
14793
14794
14795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14796   Dali::Property *arg1 = (Dali::Property *) 0 ;
14797
14798   arg1 = (Dali::Property *)jarg1;
14799   {
14800     try {
14801       delete arg1;
14802     } catch (std::out_of_range& e) {
14803       {
14804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14805       };
14806     } catch (std::exception& e) {
14807       {
14808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14809       };
14810     } catch (Dali::DaliException e) {
14811       {
14812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14813       };
14814     } catch (...) {
14815       {
14816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14817       };
14818     }
14819   }
14820
14821 }
14822
14823
14824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14825   Dali::Property *arg1 = (Dali::Property *) 0 ;
14826   Dali::Handle *arg2 = 0 ;
14827
14828   arg1 = (Dali::Property *)jarg1;
14829   arg2 = (Dali::Handle *)jarg2;
14830   if (!arg2) {
14831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14832     return ;
14833   }
14834   if (arg1) (arg1)->object = *arg2;
14835 }
14836
14837
14838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14839   void * jresult ;
14840   Dali::Property *arg1 = (Dali::Property *) 0 ;
14841   Dali::Handle *result = 0 ;
14842
14843   arg1 = (Dali::Property *)jarg1;
14844   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14845   jresult = (void *)result;
14846   return jresult;
14847 }
14848
14849
14850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14851   Dali::Property *arg1 = (Dali::Property *) 0 ;
14852   Dali::Property::Index arg2 ;
14853
14854   arg1 = (Dali::Property *)jarg1;
14855   arg2 = (Dali::Property::Index)jarg2;
14856   if (arg1) (arg1)->propertyIndex = arg2;
14857 }
14858
14859
14860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14861   int jresult ;
14862   Dali::Property *arg1 = (Dali::Property *) 0 ;
14863   Dali::Property::Index result;
14864
14865   arg1 = (Dali::Property *)jarg1;
14866   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14867   jresult = result;
14868   return jresult;
14869 }
14870
14871
14872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14873   Dali::Property *arg1 = (Dali::Property *) 0 ;
14874   int arg2 ;
14875
14876   arg1 = (Dali::Property *)jarg1;
14877   arg2 = (int)jarg2;
14878   if (arg1) (arg1)->componentIndex = arg2;
14879 }
14880
14881
14882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14883   int jresult ;
14884   Dali::Property *arg1 = (Dali::Property *) 0 ;
14885   int result;
14886
14887   arg1 = (Dali::Property *)jarg1;
14888   result = (int) ((arg1)->componentIndex);
14889   jresult = result;
14890   return jresult;
14891 }
14892
14893
14894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14895   void * jresult ;
14896   Dali::Property::Array *result = 0 ;
14897
14898   {
14899     try {
14900       result = (Dali::Property::Array *)new Dali::Property::Array();
14901     } catch (std::out_of_range& e) {
14902       {
14903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14904       };
14905     } catch (std::exception& e) {
14906       {
14907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14908       };
14909     } catch (Dali::DaliException e) {
14910       {
14911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14912       };
14913     } catch (...) {
14914       {
14915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14916       };
14917     }
14918   }
14919
14920   jresult = (void *)result;
14921   return jresult;
14922 }
14923
14924
14925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14926   void * jresult ;
14927   Dali::Property::Array *arg1 = 0 ;
14928   Dali::Property::Array *result = 0 ;
14929
14930   arg1 = (Dali::Property::Array *)jarg1;
14931   if (!arg1) {
14932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14933     return 0;
14934   }
14935   {
14936     try {
14937       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14938     } catch (std::out_of_range& e) {
14939       {
14940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14941       };
14942     } catch (std::exception& e) {
14943       {
14944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14945       };
14946     } catch (Dali::DaliException e) {
14947       {
14948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14949       };
14950     } catch (...) {
14951       {
14952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14953       };
14954     }
14955   }
14956
14957   jresult = (void *)result;
14958   return jresult;
14959 }
14960
14961
14962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14963   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14964
14965   arg1 = (Dali::Property::Array *)jarg1;
14966   {
14967     try {
14968       delete arg1;
14969     } catch (std::out_of_range& e) {
14970       {
14971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14972       };
14973     } catch (std::exception& e) {
14974       {
14975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14976       };
14977     } catch (Dali::DaliException e) {
14978       {
14979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14980       };
14981     } catch (...) {
14982       {
14983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14984       };
14985     }
14986   }
14987
14988 }
14989
14990
14991 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14992   unsigned long jresult ;
14993   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14994   Dali::Property::Array::SizeType result;
14995
14996   arg1 = (Dali::Property::Array *)jarg1;
14997   {
14998     try {
14999       result = ((Dali::Property::Array const *)arg1)->Size();
15000     } catch (std::out_of_range& e) {
15001       {
15002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15003       };
15004     } catch (std::exception& e) {
15005       {
15006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15007       };
15008     } catch (Dali::DaliException e) {
15009       {
15010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15011       };
15012     } catch (...) {
15013       {
15014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15015       };
15016     }
15017   }
15018
15019   jresult = (unsigned long)result;
15020   return jresult;
15021 }
15022
15023
15024 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15025   unsigned long jresult ;
15026   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15027   Dali::Property::Array::SizeType result;
15028
15029   arg1 = (Dali::Property::Array *)jarg1;
15030   {
15031     try {
15032       result = ((Dali::Property::Array const *)arg1)->Count();
15033     } catch (std::out_of_range& e) {
15034       {
15035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15036       };
15037     } catch (std::exception& e) {
15038       {
15039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15040       };
15041     } catch (Dali::DaliException e) {
15042       {
15043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15044       };
15045     } catch (...) {
15046       {
15047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15048       };
15049     }
15050   }
15051
15052   jresult = (unsigned long)result;
15053   return jresult;
15054 }
15055
15056
15057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15058   unsigned int jresult ;
15059   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15060   bool result;
15061
15062   arg1 = (Dali::Property::Array *)jarg1;
15063   {
15064     try {
15065       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15066     } catch (std::out_of_range& e) {
15067       {
15068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15069       };
15070     } catch (std::exception& e) {
15071       {
15072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15073       };
15074     } catch (Dali::DaliException e) {
15075       {
15076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15077       };
15078     } catch (...) {
15079       {
15080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15081       };
15082     }
15083   }
15084
15085   jresult = result;
15086   return jresult;
15087 }
15088
15089
15090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15091   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15092
15093   arg1 = (Dali::Property::Array *)jarg1;
15094   {
15095     try {
15096       (arg1)->Clear();
15097     } catch (std::out_of_range& e) {
15098       {
15099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15100       };
15101     } catch (std::exception& e) {
15102       {
15103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15104       };
15105     } catch (Dali::DaliException e) {
15106       {
15107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15108       };
15109     } catch (...) {
15110       {
15111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15112       };
15113     }
15114   }
15115
15116 }
15117
15118
15119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15120   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15121   Dali::Property::Array::SizeType arg2 ;
15122
15123   arg1 = (Dali::Property::Array *)jarg1;
15124   arg2 = (Dali::Property::Array::SizeType)jarg2;
15125   {
15126     try {
15127       (arg1)->Reserve(arg2);
15128     } catch (std::out_of_range& e) {
15129       {
15130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15131       };
15132     } catch (std::exception& e) {
15133       {
15134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15135       };
15136     } catch (Dali::DaliException e) {
15137       {
15138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15139       };
15140     } catch (...) {
15141       {
15142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15143       };
15144     }
15145   }
15146
15147 }
15148
15149
15150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15151   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15152   Dali::Property::Array::SizeType arg2 ;
15153
15154   arg1 = (Dali::Property::Array *)jarg1;
15155   arg2 = (Dali::Property::Array::SizeType)jarg2;
15156   {
15157     try {
15158       (arg1)->Resize(arg2);
15159     } catch (std::out_of_range& e) {
15160       {
15161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15162       };
15163     } catch (std::exception& e) {
15164       {
15165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15166       };
15167     } catch (Dali::DaliException e) {
15168       {
15169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15170       };
15171     } catch (...) {
15172       {
15173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15174       };
15175     }
15176   }
15177
15178 }
15179
15180
15181 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15182   unsigned long jresult ;
15183   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15184   Dali::Property::Array::SizeType result;
15185
15186   arg1 = (Dali::Property::Array *)jarg1;
15187   {
15188     try {
15189       result = (arg1)->Capacity();
15190     } catch (std::out_of_range& e) {
15191       {
15192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15193       };
15194     } catch (std::exception& e) {
15195       {
15196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15197       };
15198     } catch (Dali::DaliException e) {
15199       {
15200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15201       };
15202     } catch (...) {
15203       {
15204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15205       };
15206     }
15207   }
15208
15209   jresult = (unsigned long)result;
15210   return jresult;
15211 }
15212
15213
15214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15215   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15216   Dali::Property::Value *arg2 = 0 ;
15217
15218   arg1 = (Dali::Property::Array *)jarg1;
15219   arg2 = (Dali::Property::Value *)jarg2;
15220   if (!arg2) {
15221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15222     return ;
15223   }
15224   {
15225     try {
15226       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15227     } catch (std::out_of_range& e) {
15228       {
15229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15230       };
15231     } catch (std::exception& e) {
15232       {
15233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15234       };
15235     } catch (Dali::DaliException e) {
15236       {
15237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15238       };
15239     } catch (...) {
15240       {
15241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15242       };
15243     }
15244   }
15245
15246 }
15247
15248
15249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15250   void * jresult ;
15251   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15252   Dali::Property::Value *arg2 = 0 ;
15253   Dali::Property::Array *result = 0 ;
15254
15255   arg1 = (Dali::Property::Array *)jarg1;
15256   arg2 = (Dali::Property::Value *)jarg2;
15257   if (!arg2) {
15258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15259     return 0;
15260   }
15261   {
15262     try {
15263       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15264     } catch (std::out_of_range& e) {
15265       {
15266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15267       };
15268     } catch (std::exception& e) {
15269       {
15270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15271       };
15272     } catch (Dali::DaliException e) {
15273       {
15274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15275       };
15276     } catch (...) {
15277       {
15278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15279       };
15280     }
15281   }
15282
15283   jresult = (void *)result;
15284   return jresult;
15285 }
15286
15287
15288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15289   void * jresult ;
15290   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15291   Dali::Property::Array::SizeType arg2 ;
15292   Dali::Property::Value *result = 0 ;
15293
15294   arg1 = (Dali::Property::Array *)jarg1;
15295   arg2 = (Dali::Property::Array::SizeType)jarg2;
15296   {
15297     try {
15298       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15299     } catch (std::out_of_range& e) {
15300       {
15301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15302       };
15303     } catch (std::exception& e) {
15304       {
15305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15306       };
15307     } catch (Dali::DaliException e) {
15308       {
15309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15310       };
15311     } catch (...) {
15312       {
15313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15314       };
15315     }
15316   }
15317
15318   jresult = (void *)result;
15319   return jresult;
15320 }
15321
15322
15323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15324   void * jresult ;
15325   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15326   Dali::Property::Array::SizeType arg2 ;
15327   Dali::Property::Value *result = 0 ;
15328
15329   arg1 = (Dali::Property::Array *)jarg1;
15330   arg2 = (Dali::Property::Array::SizeType)jarg2;
15331   {
15332     try {
15333       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15334     } catch (std::out_of_range& e) {
15335       {
15336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15337       };
15338     } catch (std::exception& e) {
15339       {
15340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15341       };
15342     } catch (Dali::DaliException e) {
15343       {
15344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15345       };
15346     } catch (...) {
15347       {
15348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15349       };
15350     }
15351   }
15352
15353   jresult = (void *)result;
15354   return jresult;
15355 }
15356
15357
15358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15359   void * jresult ;
15360   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15361   Dali::Property::Array *arg2 = 0 ;
15362   Dali::Property::Array *result = 0 ;
15363
15364   arg1 = (Dali::Property::Array *)jarg1;
15365   arg2 = (Dali::Property::Array *)jarg2;
15366   if (!arg2) {
15367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15368     return 0;
15369   }
15370   {
15371     try {
15372       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15373     } catch (std::out_of_range& e) {
15374       {
15375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15376       };
15377     } catch (std::exception& e) {
15378       {
15379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15380       };
15381     } catch (Dali::DaliException e) {
15382       {
15383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15384       };
15385     } catch (...) {
15386       {
15387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15388       };
15389     }
15390   }
15391
15392   jresult = (void *)result;
15393   return jresult;
15394 }
15395
15396
15397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15398   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15399   enum Dali::Property::Key::Type arg2 ;
15400
15401   arg1 = (Dali::Property::Key *)jarg1;
15402   arg2 = (enum Dali::Property::Key::Type)jarg2;
15403   if (arg1) (arg1)->type = arg2;
15404 }
15405
15406
15407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15408   int jresult ;
15409   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15410   enum Dali::Property::Key::Type result;
15411
15412   arg1 = (Dali::Property::Key *)jarg1;
15413   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15414   jresult = (int)result;
15415   return jresult;
15416 }
15417
15418
15419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15420   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15421   Dali::Property::Index arg2 ;
15422
15423   arg1 = (Dali::Property::Key *)jarg1;
15424   arg2 = (Dali::Property::Index)jarg2;
15425   if (arg1) (arg1)->indexKey = arg2;
15426 }
15427
15428
15429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15430   int jresult ;
15431   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15432   Dali::Property::Index result;
15433
15434   arg1 = (Dali::Property::Key *)jarg1;
15435   result = (Dali::Property::Index) ((arg1)->indexKey);
15436   jresult = result;
15437   return jresult;
15438 }
15439
15440
15441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15442   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15443   std::string *arg2 = 0 ;
15444
15445   arg1 = (Dali::Property::Key *)jarg1;
15446   if (!jarg2) {
15447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15448     return ;
15449   }
15450   std::string arg2_str(jarg2);
15451   arg2 = &arg2_str;
15452   if (arg1) (arg1)->stringKey = *arg2;
15453
15454   //argout typemap for const std::string&
15455
15456 }
15457
15458
15459 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15460   char * jresult ;
15461   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15462   std::string *result = 0 ;
15463
15464   arg1 = (Dali::Property::Key *)jarg1;
15465   result = (std::string *) & ((arg1)->stringKey);
15466   jresult = SWIG_csharp_string_callback(result->c_str());
15467   return jresult;
15468 }
15469
15470
15471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15472   void * jresult ;
15473   std::string *arg1 = 0 ;
15474   Dali::Property::Key *result = 0 ;
15475
15476   if (!jarg1) {
15477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15478     return 0;
15479   }
15480   std::string arg1_str(jarg1);
15481   arg1 = &arg1_str;
15482   {
15483     try {
15484       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15485     } catch (std::out_of_range& e) {
15486       {
15487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15488       };
15489     } catch (std::exception& e) {
15490       {
15491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15492       };
15493     } catch (Dali::DaliException e) {
15494       {
15495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15496       };
15497     } catch (...) {
15498       {
15499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15500       };
15501     }
15502   }
15503
15504   jresult = (void *)result;
15505
15506   //argout typemap for const std::string&
15507
15508   return jresult;
15509 }
15510
15511
15512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15513   void * jresult ;
15514   Dali::Property::Index arg1 ;
15515   Dali::Property::Key *result = 0 ;
15516
15517   arg1 = (Dali::Property::Index)jarg1;
15518   {
15519     try {
15520       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15521     } catch (std::out_of_range& e) {
15522       {
15523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15524       };
15525     } catch (std::exception& e) {
15526       {
15527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15528       };
15529     } catch (Dali::DaliException e) {
15530       {
15531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15532       };
15533     } catch (...) {
15534       {
15535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15536       };
15537     }
15538   }
15539
15540   jresult = (void *)result;
15541   return jresult;
15542 }
15543
15544
15545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15546   unsigned int jresult ;
15547   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15548   std::string *arg2 = 0 ;
15549   bool result;
15550
15551   arg1 = (Dali::Property::Key *)jarg1;
15552   if (!jarg2) {
15553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15554     return 0;
15555   }
15556   std::string arg2_str(jarg2);
15557   arg2 = &arg2_str;
15558   {
15559     try {
15560       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15561     } catch (std::out_of_range& e) {
15562       {
15563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15564       };
15565     } catch (std::exception& e) {
15566       {
15567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15568       };
15569     } catch (Dali::DaliException e) {
15570       {
15571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15572       };
15573     } catch (...) {
15574       {
15575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15576       };
15577     }
15578   }
15579
15580   jresult = result;
15581
15582   //argout typemap for const std::string&
15583
15584   return jresult;
15585 }
15586
15587
15588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15589   unsigned int jresult ;
15590   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15591   Dali::Property::Index arg2 ;
15592   bool result;
15593
15594   arg1 = (Dali::Property::Key *)jarg1;
15595   arg2 = (Dali::Property::Index)jarg2;
15596   {
15597     try {
15598       result = (bool)(arg1)->operator ==(arg2);
15599     } catch (std::out_of_range& e) {
15600       {
15601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15602       };
15603     } catch (std::exception& e) {
15604       {
15605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15606       };
15607     } catch (Dali::DaliException e) {
15608       {
15609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15610       };
15611     } catch (...) {
15612       {
15613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15614       };
15615     }
15616   }
15617
15618   jresult = result;
15619   return jresult;
15620 }
15621
15622
15623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15624   unsigned int jresult ;
15625   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15626   Dali::Property::Key *arg2 = 0 ;
15627   bool result;
15628
15629   arg1 = (Dali::Property::Key *)jarg1;
15630   arg2 = (Dali::Property::Key *)jarg2;
15631   if (!arg2) {
15632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15633     return 0;
15634   }
15635   {
15636     try {
15637       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15638     } catch (std::out_of_range& e) {
15639       {
15640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15641       };
15642     } catch (std::exception& e) {
15643       {
15644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15645       };
15646     } catch (Dali::DaliException e) {
15647       {
15648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15649       };
15650     } catch (...) {
15651       {
15652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15653       };
15654     }
15655   }
15656
15657   jresult = result;
15658   return jresult;
15659 }
15660
15661
15662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15663   unsigned int jresult ;
15664   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15665   std::string *arg2 = 0 ;
15666   bool result;
15667
15668   arg1 = (Dali::Property::Key *)jarg1;
15669   if (!jarg2) {
15670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15671     return 0;
15672   }
15673   std::string arg2_str(jarg2);
15674   arg2 = &arg2_str;
15675   {
15676     try {
15677       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15678     } catch (std::out_of_range& e) {
15679       {
15680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15681       };
15682     } catch (std::exception& e) {
15683       {
15684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15685       };
15686     } catch (Dali::DaliException e) {
15687       {
15688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15689       };
15690     } catch (...) {
15691       {
15692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15693       };
15694     }
15695   }
15696
15697   jresult = result;
15698
15699   //argout typemap for const std::string&
15700
15701   return jresult;
15702 }
15703
15704
15705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15706   unsigned int jresult ;
15707   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15708   Dali::Property::Index arg2 ;
15709   bool result;
15710
15711   arg1 = (Dali::Property::Key *)jarg1;
15712   arg2 = (Dali::Property::Index)jarg2;
15713   {
15714     try {
15715       result = (bool)(arg1)->operator !=(arg2);
15716     } catch (std::out_of_range& e) {
15717       {
15718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15719       };
15720     } catch (std::exception& e) {
15721       {
15722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15723       };
15724     } catch (Dali::DaliException e) {
15725       {
15726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15727       };
15728     } catch (...) {
15729       {
15730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15731       };
15732     }
15733   }
15734
15735   jresult = result;
15736   return jresult;
15737 }
15738
15739
15740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15741   unsigned int jresult ;
15742   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15743   Dali::Property::Key *arg2 = 0 ;
15744   bool result;
15745
15746   arg1 = (Dali::Property::Key *)jarg1;
15747   arg2 = (Dali::Property::Key *)jarg2;
15748   if (!arg2) {
15749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15750     return 0;
15751   }
15752   {
15753     try {
15754       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15755     } catch (std::out_of_range& e) {
15756       {
15757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15758       };
15759     } catch (std::exception& e) {
15760       {
15761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15762       };
15763     } catch (Dali::DaliException e) {
15764       {
15765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15766       };
15767     } catch (...) {
15768       {
15769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15770       };
15771     }
15772   }
15773
15774   jresult = result;
15775   return jresult;
15776 }
15777
15778
15779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15780   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15781
15782   arg1 = (Dali::Property::Key *)jarg1;
15783   {
15784     try {
15785       delete arg1;
15786     } catch (std::out_of_range& e) {
15787       {
15788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15789       };
15790     } catch (std::exception& e) {
15791       {
15792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15793       };
15794     } catch (Dali::DaliException e) {
15795       {
15796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15797       };
15798     } catch (...) {
15799       {
15800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15801       };
15802     }
15803   }
15804
15805 }
15806
15807
15808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15809   void * jresult ;
15810   Dali::Property::Map *result = 0 ;
15811
15812   {
15813     try {
15814       result = (Dali::Property::Map *)new Dali::Property::Map();
15815     } catch (std::out_of_range& e) {
15816       {
15817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15818       };
15819     } catch (std::exception& e) {
15820       {
15821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15822       };
15823     } catch (Dali::DaliException e) {
15824       {
15825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15826       };
15827     } catch (...) {
15828       {
15829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15830       };
15831     }
15832   }
15833
15834   jresult = (void *)result;
15835   return jresult;
15836 }
15837
15838
15839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15840   void * jresult ;
15841   Dali::Property::Map *arg1 = 0 ;
15842   Dali::Property::Map *result = 0 ;
15843
15844   arg1 = (Dali::Property::Map *)jarg1;
15845   if (!arg1) {
15846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15847     return 0;
15848   }
15849   {
15850     try {
15851       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15852     } catch (std::out_of_range& e) {
15853       {
15854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15855       };
15856     } catch (std::exception& e) {
15857       {
15858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15859       };
15860     } catch (Dali::DaliException e) {
15861       {
15862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15863       };
15864     } catch (...) {
15865       {
15866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15867       };
15868     }
15869   }
15870
15871   jresult = (void *)result;
15872   return jresult;
15873 }
15874
15875
15876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15877   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15878
15879   arg1 = (Dali::Property::Map *)jarg1;
15880   {
15881     try {
15882       delete arg1;
15883     } catch (std::out_of_range& e) {
15884       {
15885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15886       };
15887     } catch (std::exception& e) {
15888       {
15889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15890       };
15891     } catch (Dali::DaliException e) {
15892       {
15893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15894       };
15895     } catch (...) {
15896       {
15897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15898       };
15899     }
15900   }
15901
15902 }
15903
15904
15905 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15906   unsigned long jresult ;
15907   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15908   Dali::Property::Map::SizeType result;
15909
15910   arg1 = (Dali::Property::Map *)jarg1;
15911   {
15912     try {
15913       result = ((Dali::Property::Map const *)arg1)->Count();
15914     } catch (std::out_of_range& e) {
15915       {
15916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15917       };
15918     } catch (std::exception& e) {
15919       {
15920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15921       };
15922     } catch (Dali::DaliException e) {
15923       {
15924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15925       };
15926     } catch (...) {
15927       {
15928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15929       };
15930     }
15931   }
15932
15933   jresult = (unsigned long)result;
15934   return jresult;
15935 }
15936
15937
15938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15939   unsigned int jresult ;
15940   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15941   bool result;
15942
15943   arg1 = (Dali::Property::Map *)jarg1;
15944   {
15945     try {
15946       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15947     } catch (std::out_of_range& e) {
15948       {
15949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15950       };
15951     } catch (std::exception& e) {
15952       {
15953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15954       };
15955     } catch (Dali::DaliException e) {
15956       {
15957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15958       };
15959     } catch (...) {
15960       {
15961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15962       };
15963     }
15964   }
15965
15966   jresult = result;
15967   return jresult;
15968 }
15969
15970
15971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15972   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15973   char *arg2 = (char *) 0 ;
15974   Dali::Property::Value *arg3 = 0 ;
15975
15976   arg1 = (Dali::Property::Map *)jarg1;
15977   arg2 = (char *)jarg2;
15978   arg3 = (Dali::Property::Value *)jarg3;
15979   if (!arg3) {
15980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15981     return ;
15982   }
15983   {
15984     try {
15985       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15986     } catch (std::out_of_range& e) {
15987       {
15988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15989       };
15990     } catch (std::exception& e) {
15991       {
15992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15993       };
15994     } catch (Dali::DaliException e) {
15995       {
15996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15997       };
15998     } catch (...) {
15999       {
16000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16001       };
16002     }
16003   }
16004
16005 }
16006
16007
16008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16009   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16010   Dali::Property::Index arg2 ;
16011   Dali::Property::Value *arg3 = 0 ;
16012
16013   arg1 = (Dali::Property::Map *)jarg1;
16014   arg2 = (Dali::Property::Index)jarg2;
16015   arg3 = (Dali::Property::Value *)jarg3;
16016   if (!arg3) {
16017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16018     return ;
16019   }
16020   {
16021     try {
16022       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16023     } catch (std::out_of_range& e) {
16024       {
16025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16026       };
16027     } catch (std::exception& e) {
16028       {
16029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16030       };
16031     } catch (Dali::DaliException e) {
16032       {
16033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16034       };
16035     } catch (...) {
16036       {
16037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16038       };
16039     }
16040   }
16041
16042 }
16043
16044
16045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16046   void * jresult ;
16047   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16048   char *arg2 = (char *) 0 ;
16049   Dali::Property::Value *arg3 = 0 ;
16050   Dali::Property::Map *result = 0 ;
16051
16052   arg1 = (Dali::Property::Map *)jarg1;
16053   arg2 = (char *)jarg2;
16054   arg3 = (Dali::Property::Value *)jarg3;
16055   if (!arg3) {
16056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16057     return 0;
16058   }
16059   {
16060     try {
16061       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16062     } catch (std::out_of_range& e) {
16063       {
16064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16065       };
16066     } catch (std::exception& e) {
16067       {
16068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16069       };
16070     } catch (Dali::DaliException e) {
16071       {
16072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16073       };
16074     } catch (...) {
16075       {
16076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16077       };
16078     }
16079   }
16080
16081   jresult = (void *)result;
16082   return jresult;
16083 }
16084
16085
16086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16087   void * jresult ;
16088   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16089   Dali::Property::Index arg2 ;
16090   Dali::Property::Value *arg3 = 0 ;
16091   Dali::Property::Map *result = 0 ;
16092
16093   arg1 = (Dali::Property::Map *)jarg1;
16094   arg2 = (Dali::Property::Index)jarg2;
16095   arg3 = (Dali::Property::Value *)jarg3;
16096   if (!arg3) {
16097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16098     return 0;
16099   }
16100   {
16101     try {
16102       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16103     } catch (std::out_of_range& e) {
16104       {
16105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16106       };
16107     } catch (std::exception& e) {
16108       {
16109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16110       };
16111     } catch (Dali::DaliException e) {
16112       {
16113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16114       };
16115     } catch (...) {
16116       {
16117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16118       };
16119     }
16120   }
16121
16122   jresult = (void *)result;
16123   return jresult;
16124 }
16125
16126
16127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16128   void * jresult ;
16129   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16130   Dali::Property::Map::SizeType arg2 ;
16131   Dali::Property::Value *result = 0 ;
16132
16133   arg1 = (Dali::Property::Map *)jarg1;
16134   arg2 = (Dali::Property::Map::SizeType)jarg2;
16135   {
16136     try {
16137       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16138     } catch (std::out_of_range& e) {
16139       {
16140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16141       };
16142     } catch (std::exception& e) {
16143       {
16144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (Dali::DaliException e) {
16147       {
16148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16149       };
16150     } catch (...) {
16151       {
16152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16153       };
16154     }
16155   }
16156
16157   jresult = (void *)result;
16158   return jresult;
16159 }
16160
16161
16162 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16163   char * jresult ;
16164   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16165   Dali::Property::Map::SizeType arg2 ;
16166   std::string *result = 0 ;
16167
16168   arg1 = (Dali::Property::Map *)jarg1;
16169   arg2 = (Dali::Property::Map::SizeType)jarg2;
16170   {
16171     try {
16172       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16173     } catch (std::out_of_range& e) {
16174       {
16175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16176       };
16177     } catch (std::exception& e) {
16178       {
16179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16180       };
16181     } catch (Dali::DaliException e) {
16182       {
16183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16184       };
16185     } catch (...) {
16186       {
16187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16188       };
16189     }
16190   }
16191
16192   jresult = SWIG_csharp_string_callback(result->c_str());
16193   return jresult;
16194 }
16195
16196
16197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16198   void * jresult ;
16199   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16200   Dali::Property::Map::SizeType arg2 ;
16201   SwigValueWrapper< Dali::Property::Key > result;
16202
16203   arg1 = (Dali::Property::Map *)jarg1;
16204   arg2 = (Dali::Property::Map::SizeType)jarg2;
16205   {
16206     try {
16207       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16208     } catch (std::out_of_range& e) {
16209       {
16210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16211       };
16212     } catch (std::exception& e) {
16213       {
16214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16215       };
16216     } catch (Dali::DaliException e) {
16217       {
16218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16219       };
16220     } catch (...) {
16221       {
16222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16223       };
16224     }
16225   }
16226
16227   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16228   return jresult;
16229 }
16230
16231
16232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16233   void * jresult ;
16234   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16235   Dali::Property::Map::SizeType arg2 ;
16236   StringValuePair *result = 0 ;
16237
16238   arg1 = (Dali::Property::Map *)jarg1;
16239   arg2 = (Dali::Property::Map::SizeType)jarg2;
16240   {
16241     try {
16242       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16243     } catch (std::out_of_range& e) {
16244       {
16245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16246       };
16247     } catch (std::exception& e) {
16248       {
16249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16250       };
16251     } catch (Dali::DaliException e) {
16252       {
16253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16254       };
16255     } catch (...) {
16256       {
16257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16258       };
16259     }
16260   }
16261
16262   jresult = (void *)result;
16263   return jresult;
16264 }
16265
16266
16267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16268   void * jresult ;
16269   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16270   char *arg2 = (char *) 0 ;
16271   Dali::Property::Value *result = 0 ;
16272
16273   arg1 = (Dali::Property::Map *)jarg1;
16274   arg2 = (char *)jarg2;
16275   {
16276     try {
16277       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16278     } catch (std::out_of_range& e) {
16279       {
16280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16281       };
16282     } catch (std::exception& e) {
16283       {
16284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16285       };
16286     } catch (Dali::DaliException e) {
16287       {
16288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16289       };
16290     } catch (...) {
16291       {
16292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16293       };
16294     }
16295   }
16296
16297   jresult = (void *)result;
16298   return jresult;
16299 }
16300
16301
16302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16303   void * jresult ;
16304   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16305   Dali::Property::Index arg2 ;
16306   Dali::Property::Value *result = 0 ;
16307
16308   arg1 = (Dali::Property::Map *)jarg1;
16309   arg2 = (Dali::Property::Index)jarg2;
16310   {
16311     try {
16312       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16313     } catch (std::out_of_range& e) {
16314       {
16315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16316       };
16317     } catch (std::exception& e) {
16318       {
16319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16320       };
16321     } catch (Dali::DaliException e) {
16322       {
16323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16324       };
16325     } catch (...) {
16326       {
16327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16328       };
16329     }
16330   }
16331
16332   jresult = (void *)result;
16333   return jresult;
16334 }
16335
16336
16337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16338   void * jresult ;
16339   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16340   Dali::Property::Index arg2 ;
16341   std::string *arg3 = 0 ;
16342   Dali::Property::Value *result = 0 ;
16343
16344   arg1 = (Dali::Property::Map *)jarg1;
16345   arg2 = (Dali::Property::Index)jarg2;
16346   if (!jarg3) {
16347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16348     return 0;
16349   }
16350   std::string arg3_str(jarg3);
16351   arg3 = &arg3_str;
16352   {
16353     try {
16354       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16355     } catch (std::out_of_range& e) {
16356       {
16357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16358       };
16359     } catch (std::exception& e) {
16360       {
16361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16362       };
16363     } catch (Dali::DaliException e) {
16364       {
16365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16366       };
16367     } catch (...) {
16368       {
16369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16370       };
16371     }
16372   }
16373
16374   jresult = (void *)result;
16375
16376   //argout typemap for const std::string&
16377
16378   return jresult;
16379 }
16380
16381
16382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16383   void * jresult ;
16384   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16385   std::string *arg2 = 0 ;
16386   Dali::Property::Type arg3 ;
16387   Dali::Property::Value *result = 0 ;
16388
16389   arg1 = (Dali::Property::Map *)jarg1;
16390   if (!jarg2) {
16391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16392     return 0;
16393   }
16394   std::string arg2_str(jarg2);
16395   arg2 = &arg2_str;
16396   arg3 = (Dali::Property::Type)jarg3;
16397   {
16398     try {
16399       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16400     } catch (std::out_of_range& e) {
16401       {
16402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16403       };
16404     } catch (std::exception& e) {
16405       {
16406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16407       };
16408     } catch (Dali::DaliException e) {
16409       {
16410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16411       };
16412     } catch (...) {
16413       {
16414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16415       };
16416     }
16417   }
16418
16419   jresult = (void *)result;
16420
16421   //argout typemap for const std::string&
16422
16423   return jresult;
16424 }
16425
16426
16427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16428   void * jresult ;
16429   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16430   Dali::Property::Index arg2 ;
16431   Dali::Property::Type arg3 ;
16432   Dali::Property::Value *result = 0 ;
16433
16434   arg1 = (Dali::Property::Map *)jarg1;
16435   arg2 = (Dali::Property::Index)jarg2;
16436   arg3 = (Dali::Property::Type)jarg3;
16437   {
16438     try {
16439       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16440     } catch (std::out_of_range& e) {
16441       {
16442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16443       };
16444     } catch (std::exception& e) {
16445       {
16446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16447       };
16448     } catch (Dali::DaliException e) {
16449       {
16450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16451       };
16452     } catch (...) {
16453       {
16454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16455       };
16456     }
16457   }
16458
16459   jresult = (void *)result;
16460   return jresult;
16461 }
16462
16463
16464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16465   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16466
16467   arg1 = (Dali::Property::Map *)jarg1;
16468   {
16469     try {
16470       (arg1)->Clear();
16471     } catch (std::out_of_range& e) {
16472       {
16473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16474       };
16475     } catch (std::exception& e) {
16476       {
16477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16478       };
16479     } catch (Dali::DaliException e) {
16480       {
16481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16482       };
16483     } catch (...) {
16484       {
16485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16486       };
16487     }
16488   }
16489
16490 }
16491
16492
16493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16494   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16495   Dali::Property::Map *arg2 = 0 ;
16496
16497   arg1 = (Dali::Property::Map *)jarg1;
16498   arg2 = (Dali::Property::Map *)jarg2;
16499   if (!arg2) {
16500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16501     return ;
16502   }
16503   {
16504     try {
16505       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16506     } catch (std::out_of_range& e) {
16507       {
16508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16509       };
16510     } catch (std::exception& e) {
16511       {
16512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16513       };
16514     } catch (Dali::DaliException e) {
16515       {
16516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16517       };
16518     } catch (...) {
16519       {
16520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16521       };
16522     }
16523   }
16524
16525 }
16526
16527
16528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16529   void * jresult ;
16530   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16531   std::string *arg2 = 0 ;
16532   Dali::Property::Value *result = 0 ;
16533
16534   arg1 = (Dali::Property::Map *)jarg1;
16535   if (!jarg2) {
16536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16537     return 0;
16538   }
16539   std::string arg2_str(jarg2);
16540   arg2 = &arg2_str;
16541   {
16542     try {
16543       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16544     } catch (std::out_of_range& e) {
16545       {
16546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16547       };
16548     } catch (std::exception& e) {
16549       {
16550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16551       };
16552     } catch (Dali::DaliException e) {
16553       {
16554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16555       };
16556     } catch (...) {
16557       {
16558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16559       };
16560     }
16561   }
16562
16563   jresult = (void *)result;
16564
16565   //argout typemap for const std::string&
16566
16567   return jresult;
16568 }
16569
16570
16571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16572   void * jresult ;
16573   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16574   Dali::Property::Index arg2 ;
16575   Dali::Property::Value *result = 0 ;
16576
16577   arg1 = (Dali::Property::Map *)jarg1;
16578   arg2 = (Dali::Property::Index)jarg2;
16579   {
16580     try {
16581       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16582     } catch (std::out_of_range& e) {
16583       {
16584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16585       };
16586     } catch (std::exception& e) {
16587       {
16588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16589       };
16590     } catch (Dali::DaliException e) {
16591       {
16592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16593       };
16594     } catch (...) {
16595       {
16596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16597       };
16598     }
16599   }
16600
16601   jresult = (void *)result;
16602   return jresult;
16603 }
16604
16605
16606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16607   void * jresult ;
16608   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16609   Dali::Property::Map *arg2 = 0 ;
16610   Dali::Property::Map *result = 0 ;
16611
16612   arg1 = (Dali::Property::Map *)jarg1;
16613   arg2 = (Dali::Property::Map *)jarg2;
16614   if (!arg2) {
16615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16616     return 0;
16617   }
16618   {
16619     try {
16620       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16621     } catch (std::out_of_range& e) {
16622       {
16623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16624       };
16625     } catch (std::exception& e) {
16626       {
16627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16628       };
16629     } catch (Dali::DaliException e) {
16630       {
16631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16632       };
16633     } catch (...) {
16634       {
16635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16636       };
16637     }
16638   }
16639
16640   jresult = (void *)result;
16641   return jresult;
16642 }
16643
16644
16645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16646   void * jresult ;
16647   Dali::Property::Value *result = 0 ;
16648
16649   {
16650     try {
16651       result = (Dali::Property::Value *)new Dali::Property::Value();
16652     } catch (std::out_of_range& e) {
16653       {
16654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16655       };
16656     } catch (std::exception& e) {
16657       {
16658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16659       };
16660     } catch (Dali::DaliException e) {
16661       {
16662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16663       };
16664     } catch (...) {
16665       {
16666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16667       };
16668     }
16669   }
16670
16671   jresult = (void *)result;
16672   return jresult;
16673 }
16674
16675
16676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16677   void * jresult ;
16678   bool arg1 ;
16679   Dali::Property::Value *result = 0 ;
16680
16681   arg1 = jarg1 ? true : false;
16682   {
16683     try {
16684       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16685     } catch (std::out_of_range& e) {
16686       {
16687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16688       };
16689     } catch (std::exception& e) {
16690       {
16691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16692       };
16693     } catch (Dali::DaliException e) {
16694       {
16695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16696       };
16697     } catch (...) {
16698       {
16699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16700       };
16701     }
16702   }
16703
16704   jresult = (void *)result;
16705   return jresult;
16706 }
16707
16708
16709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16710   void * jresult ;
16711   int arg1 ;
16712   Dali::Property::Value *result = 0 ;
16713
16714   arg1 = (int)jarg1;
16715   {
16716     try {
16717       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16718     } catch (std::out_of_range& e) {
16719       {
16720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16721       };
16722     } catch (std::exception& e) {
16723       {
16724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16725       };
16726     } catch (Dali::DaliException e) {
16727       {
16728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16729       };
16730     } catch (...) {
16731       {
16732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16733       };
16734     }
16735   }
16736
16737   jresult = (void *)result;
16738   return jresult;
16739 }
16740
16741
16742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16743   void * jresult ;
16744   float arg1 ;
16745   Dali::Property::Value *result = 0 ;
16746
16747   arg1 = (float)jarg1;
16748   {
16749     try {
16750       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16751     } catch (std::out_of_range& e) {
16752       {
16753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16754       };
16755     } catch (std::exception& e) {
16756       {
16757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16758       };
16759     } catch (Dali::DaliException e) {
16760       {
16761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16762       };
16763     } catch (...) {
16764       {
16765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16766       };
16767     }
16768   }
16769
16770   jresult = (void *)result;
16771   return jresult;
16772 }
16773
16774
16775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16776   void * jresult ;
16777   Dali::Vector2 *arg1 = 0 ;
16778   Dali::Property::Value *result = 0 ;
16779
16780   arg1 = (Dali::Vector2 *)jarg1;
16781   if (!arg1) {
16782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16783     return 0;
16784   }
16785   {
16786     try {
16787       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16788     } catch (std::out_of_range& e) {
16789       {
16790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16791       };
16792     } catch (std::exception& e) {
16793       {
16794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16795       };
16796     } catch (Dali::DaliException e) {
16797       {
16798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16799       };
16800     } catch (...) {
16801       {
16802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16803       };
16804     }
16805   }
16806
16807   jresult = (void *)result;
16808   return jresult;
16809 }
16810
16811
16812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16813   void * jresult ;
16814   Dali::Vector3 *arg1 = 0 ;
16815   Dali::Property::Value *result = 0 ;
16816
16817   arg1 = (Dali::Vector3 *)jarg1;
16818   if (!arg1) {
16819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16820     return 0;
16821   }
16822   {
16823     try {
16824       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16825     } catch (std::out_of_range& e) {
16826       {
16827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16828       };
16829     } catch (std::exception& e) {
16830       {
16831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16832       };
16833     } catch (Dali::DaliException e) {
16834       {
16835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16836       };
16837     } catch (...) {
16838       {
16839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16840       };
16841     }
16842   }
16843
16844   jresult = (void *)result;
16845   return jresult;
16846 }
16847
16848
16849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16850   void * jresult ;
16851   Dali::Vector4 *arg1 = 0 ;
16852   Dali::Property::Value *result = 0 ;
16853
16854   arg1 = (Dali::Vector4 *)jarg1;
16855   if (!arg1) {
16856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16857     return 0;
16858   }
16859   {
16860     try {
16861       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16862     } catch (std::out_of_range& e) {
16863       {
16864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16865       };
16866     } catch (std::exception& e) {
16867       {
16868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16869       };
16870     } catch (Dali::DaliException e) {
16871       {
16872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16873       };
16874     } catch (...) {
16875       {
16876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16877       };
16878     }
16879   }
16880
16881   jresult = (void *)result;
16882   return jresult;
16883 }
16884
16885
16886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16887   void * jresult ;
16888   Dali::Matrix3 *arg1 = 0 ;
16889   Dali::Property::Value *result = 0 ;
16890
16891   arg1 = (Dali::Matrix3 *)jarg1;
16892   if (!arg1) {
16893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16894     return 0;
16895   }
16896   {
16897     try {
16898       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16899     } catch (std::out_of_range& e) {
16900       {
16901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (std::exception& e) {
16904       {
16905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16906       };
16907     } catch (Dali::DaliException e) {
16908       {
16909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16910       };
16911     } catch (...) {
16912       {
16913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16914       };
16915     }
16916   }
16917
16918   jresult = (void *)result;
16919   return jresult;
16920 }
16921
16922
16923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16924   void * jresult ;
16925   Dali::Matrix *arg1 = 0 ;
16926   Dali::Property::Value *result = 0 ;
16927
16928   arg1 = (Dali::Matrix *)jarg1;
16929   if (!arg1) {
16930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16931     return 0;
16932   }
16933   {
16934     try {
16935       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16936     } catch (std::out_of_range& e) {
16937       {
16938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16939       };
16940     } catch (std::exception& e) {
16941       {
16942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16943       };
16944     } catch (Dali::DaliException e) {
16945       {
16946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16947       };
16948     } catch (...) {
16949       {
16950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16951       };
16952     }
16953   }
16954
16955   jresult = (void *)result;
16956   return jresult;
16957 }
16958
16959
16960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16961   void * jresult ;
16962   Dali::Rect< int > *arg1 = 0 ;
16963   Dali::Property::Value *result = 0 ;
16964
16965   arg1 = (Dali::Rect< int > *)jarg1;
16966   if (!arg1) {
16967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16968     return 0;
16969   }
16970   {
16971     try {
16972       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16973     } catch (std::out_of_range& e) {
16974       {
16975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16976       };
16977     } catch (std::exception& e) {
16978       {
16979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16980       };
16981     } catch (Dali::DaliException e) {
16982       {
16983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16984       };
16985     } catch (...) {
16986       {
16987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16988       };
16989     }
16990   }
16991
16992   jresult = (void *)result;
16993   return jresult;
16994 }
16995
16996
16997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16998   void * jresult ;
16999   Dali::AngleAxis *arg1 = 0 ;
17000   Dali::Property::Value *result = 0 ;
17001
17002   arg1 = (Dali::AngleAxis *)jarg1;
17003   if (!arg1) {
17004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17005     return 0;
17006   }
17007   {
17008     try {
17009       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17010     } catch (std::out_of_range& e) {
17011       {
17012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (std::exception& e) {
17015       {
17016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17017       };
17018     } catch (Dali::DaliException e) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17021       };
17022     } catch (...) {
17023       {
17024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17025       };
17026     }
17027   }
17028
17029   jresult = (void *)result;
17030   return jresult;
17031 }
17032
17033
17034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17035   void * jresult ;
17036   Dali::Quaternion *arg1 = 0 ;
17037   Dali::Property::Value *result = 0 ;
17038
17039   arg1 = (Dali::Quaternion *)jarg1;
17040   if (!arg1) {
17041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17042     return 0;
17043   }
17044   {
17045     try {
17046       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17047     } catch (std::out_of_range& e) {
17048       {
17049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (std::exception& e) {
17052       {
17053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17054       };
17055     } catch (Dali::DaliException e) {
17056       {
17057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17058       };
17059     } catch (...) {
17060       {
17061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17062       };
17063     }
17064   }
17065
17066   jresult = (void *)result;
17067   return jresult;
17068 }
17069
17070
17071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17072   void * jresult ;
17073   std::string *arg1 = 0 ;
17074   Dali::Property::Value *result = 0 ;
17075
17076   if (!jarg1) {
17077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17078     return 0;
17079   }
17080   std::string arg1_str(jarg1);
17081   arg1 = &arg1_str;
17082   {
17083     try {
17084       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17085     } catch (std::out_of_range& e) {
17086       {
17087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17088       };
17089     } catch (std::exception& e) {
17090       {
17091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17092       };
17093     } catch (Dali::DaliException e) {
17094       {
17095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17096       };
17097     } catch (...) {
17098       {
17099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17100       };
17101     }
17102   }
17103
17104   jresult = (void *)result;
17105
17106   //argout typemap for const std::string&
17107
17108   return jresult;
17109 }
17110
17111
17112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17113   void * jresult ;
17114   Dali::Property::Array *arg1 = 0 ;
17115   Dali::Property::Value *result = 0 ;
17116
17117   arg1 = (Dali::Property::Array *)jarg1;
17118   if (!arg1) {
17119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17120     return 0;
17121   }
17122   {
17123     try {
17124       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17125     } catch (std::out_of_range& e) {
17126       {
17127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (std::exception& e) {
17130       {
17131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17132       };
17133     } catch (Dali::DaliException e) {
17134       {
17135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17136       };
17137     } catch (...) {
17138       {
17139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17140       };
17141     }
17142   }
17143
17144   jresult = (void *)result;
17145   return jresult;
17146 }
17147
17148
17149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17150   void * jresult ;
17151   Dali::Property::Map *arg1 = 0 ;
17152   Dali::Property::Value *result = 0 ;
17153
17154   arg1 = (Dali::Property::Map *)jarg1;
17155   if (!arg1) {
17156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17157     return 0;
17158   }
17159   {
17160     try {
17161       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17162     } catch (std::out_of_range& e) {
17163       {
17164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17165       };
17166     } catch (std::exception& e) {
17167       {
17168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17169       };
17170     } catch (Dali::DaliException e) {
17171       {
17172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17173       };
17174     } catch (...) {
17175       {
17176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17177       };
17178     }
17179   }
17180
17181   jresult = (void *)result;
17182   return jresult;
17183 }
17184
17185
17186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17187   void * jresult ;
17188   Extents *arg1 = 0 ;
17189   Dali::Property::Value *result = 0 ;
17190
17191   arg1 = (Extents *)jarg1;
17192   if (!arg1) {
17193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17194     return 0;
17195   }
17196   {
17197     try {
17198       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17199     } catch (std::out_of_range& e) {
17200       {
17201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17202       };
17203     } catch (std::exception& e) {
17204       {
17205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17206       };
17207     } catch (...) {
17208       {
17209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17210       };
17211     }
17212   }
17213   jresult = (void *)result;
17214   return jresult;
17215 }
17216
17217
17218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17219   void * jresult ;
17220   Dali::Property::Type arg1 ;
17221   Dali::Property::Value *result = 0 ;
17222
17223   arg1 = (Dali::Property::Type)jarg1;
17224   {
17225     try {
17226       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17227     } catch (std::out_of_range& e) {
17228       {
17229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17230       };
17231     } catch (std::exception& e) {
17232       {
17233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17234       };
17235     } catch (Dali::DaliException e) {
17236       {
17237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17238       };
17239     } catch (...) {
17240       {
17241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17242       };
17243     }
17244   }
17245
17246   jresult = (void *)result;
17247   return jresult;
17248 }
17249
17250
17251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17252   void * jresult ;
17253   Dali::Property::Value *arg1 = 0 ;
17254   Dali::Property::Value *result = 0 ;
17255
17256   arg1 = (Dali::Property::Value *)jarg1;
17257   if (!arg1) {
17258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17259     return 0;
17260   }
17261   {
17262     try {
17263       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17264     } catch (std::out_of_range& e) {
17265       {
17266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17267       };
17268     } catch (std::exception& e) {
17269       {
17270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17271       };
17272     } catch (Dali::DaliException e) {
17273       {
17274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17275       };
17276     } catch (...) {
17277       {
17278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17279       };
17280     }
17281   }
17282
17283   jresult = (void *)result;
17284   return jresult;
17285 }
17286
17287
17288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17289   void * jresult ;
17290   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17291   Dali::Property::Value *arg2 = 0 ;
17292   Dali::Property::Value *result = 0 ;
17293
17294   arg1 = (Dali::Property::Value *)jarg1;
17295   arg2 = (Dali::Property::Value *)jarg2;
17296   if (!arg2) {
17297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17298     return 0;
17299   }
17300   {
17301     try {
17302       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17303     } catch (std::out_of_range& e) {
17304       {
17305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17306       };
17307     } catch (std::exception& e) {
17308       {
17309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17310       };
17311     } catch (Dali::DaliException e) {
17312       {
17313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17314       };
17315     } catch (...) {
17316       {
17317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17318       };
17319     }
17320   }
17321
17322   jresult = (void *)result;
17323   return jresult;
17324 }
17325
17326
17327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17328   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17329
17330   arg1 = (Dali::Property::Value *)jarg1;
17331   {
17332     try {
17333       delete arg1;
17334     } catch (std::out_of_range& e) {
17335       {
17336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17337       };
17338     } catch (std::exception& e) {
17339       {
17340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17341       };
17342     } catch (Dali::DaliException e) {
17343       {
17344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17345       };
17346     } catch (...) {
17347       {
17348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17349       };
17350     }
17351   }
17352
17353 }
17354
17355
17356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17357   int jresult ;
17358   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17359   Dali::Property::Type result;
17360
17361   arg1 = (Dali::Property::Value *)jarg1;
17362   {
17363     try {
17364       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17365     } catch (std::out_of_range& e) {
17366       {
17367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17368       };
17369     } catch (std::exception& e) {
17370       {
17371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17372       };
17373     } catch (Dali::DaliException e) {
17374       {
17375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17376       };
17377     } catch (...) {
17378       {
17379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17380       };
17381     }
17382   }
17383
17384   jresult = (int)result;
17385   return jresult;
17386 }
17387
17388
17389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17390   unsigned int jresult ;
17391   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17392   bool *arg2 = 0 ;
17393   bool result;
17394
17395   arg1 = (Dali::Property::Value *)jarg1;
17396   arg2 = (bool *)jarg2;
17397   {
17398     try {
17399       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17400     } catch (std::out_of_range& e) {
17401       {
17402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17403       };
17404     } catch (std::exception& e) {
17405       {
17406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17407       };
17408     } catch (Dali::DaliException e) {
17409       {
17410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17411       };
17412     } catch (...) {
17413       {
17414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17415       };
17416     }
17417   }
17418
17419   jresult = result;
17420   return jresult;
17421 }
17422
17423
17424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17425   unsigned int jresult ;
17426   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17427   float *arg2 = 0 ;
17428   bool result;
17429
17430   arg1 = (Dali::Property::Value *)jarg1;
17431   arg2 = (float *)jarg2;
17432   {
17433     try {
17434       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17435     } catch (std::out_of_range& e) {
17436       {
17437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17438       };
17439     } catch (std::exception& e) {
17440       {
17441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17442       };
17443     } catch (Dali::DaliException e) {
17444       {
17445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17446       };
17447     } catch (...) {
17448       {
17449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17450       };
17451     }
17452   }
17453
17454   jresult = result;
17455   return jresult;
17456 }
17457
17458
17459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17460   unsigned int jresult ;
17461   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17462   int *arg2 = 0 ;
17463   bool result;
17464
17465   arg1 = (Dali::Property::Value *)jarg1;
17466   arg2 = (int *)jarg2;
17467   {
17468     try {
17469       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17470     } catch (std::out_of_range& e) {
17471       {
17472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17473       };
17474     } catch (std::exception& e) {
17475       {
17476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17477       };
17478     } catch (Dali::DaliException e) {
17479       {
17480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17481       };
17482     } catch (...) {
17483       {
17484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17485       };
17486     }
17487   }
17488
17489   jresult = result;
17490   return jresult;
17491 }
17492
17493
17494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17495   unsigned int jresult ;
17496   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17497   Dali::Rect< int > *arg2 = 0 ;
17498   bool result;
17499
17500   arg1 = (Dali::Property::Value *)jarg1;
17501   arg2 = (Dali::Rect< int > *)jarg2;
17502   if (!arg2) {
17503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17504     return 0;
17505   }
17506   {
17507     try {
17508       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17509     } catch (std::out_of_range& e) {
17510       {
17511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17512       };
17513     } catch (std::exception& e) {
17514       {
17515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17516       };
17517     } catch (Dali::DaliException e) {
17518       {
17519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17520       };
17521     } catch (...) {
17522       {
17523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17524       };
17525     }
17526   }
17527
17528   jresult = result;
17529   return jresult;
17530 }
17531
17532
17533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17534   unsigned int jresult ;
17535   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17536   Dali::Vector2 *arg2 = 0 ;
17537   bool result;
17538
17539   arg1 = (Dali::Property::Value *)jarg1;
17540   arg2 = (Dali::Vector2 *)jarg2;
17541   if (!arg2) {
17542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17543     return 0;
17544   }
17545   {
17546     try {
17547       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17548     } catch (std::out_of_range& e) {
17549       {
17550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17551       };
17552     } catch (std::exception& e) {
17553       {
17554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17555       };
17556     } catch (Dali::DaliException e) {
17557       {
17558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17559       };
17560     } catch (...) {
17561       {
17562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17563       };
17564     }
17565   }
17566
17567   jresult = result;
17568   return jresult;
17569 }
17570
17571
17572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17573   unsigned int jresult ;
17574   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17575   Dali::Vector3 *arg2 = 0 ;
17576   bool result;
17577
17578   arg1 = (Dali::Property::Value *)jarg1;
17579   arg2 = (Dali::Vector3 *)jarg2;
17580   if (!arg2) {
17581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17582     return 0;
17583   }
17584   {
17585     try {
17586       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17587     } catch (std::out_of_range& e) {
17588       {
17589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17590       };
17591     } catch (std::exception& e) {
17592       {
17593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17594       };
17595     } catch (Dali::DaliException e) {
17596       {
17597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17598       };
17599     } catch (...) {
17600       {
17601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17602       };
17603     }
17604   }
17605
17606   jresult = result;
17607   return jresult;
17608 }
17609
17610
17611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17612   unsigned int jresult ;
17613   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17614   Dali::Vector4 *arg2 = 0 ;
17615   bool result;
17616
17617   arg1 = (Dali::Property::Value *)jarg1;
17618   arg2 = (Dali::Vector4 *)jarg2;
17619   if (!arg2) {
17620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17621     return 0;
17622   }
17623   {
17624     try {
17625       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17626     } catch (std::out_of_range& e) {
17627       {
17628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17629       };
17630     } catch (std::exception& e) {
17631       {
17632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17633       };
17634     } catch (Dali::DaliException e) {
17635       {
17636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17637       };
17638     } catch (...) {
17639       {
17640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17641       };
17642     }
17643   }
17644
17645   jresult = result;
17646   return jresult;
17647 }
17648
17649
17650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17651   unsigned int jresult ;
17652   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17653   Dali::Matrix3 *arg2 = 0 ;
17654   bool result;
17655
17656   arg1 = (Dali::Property::Value *)jarg1;
17657   arg2 = (Dali::Matrix3 *)jarg2;
17658   if (!arg2) {
17659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17660     return 0;
17661   }
17662   {
17663     try {
17664       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17665     } catch (std::out_of_range& e) {
17666       {
17667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17668       };
17669     } catch (std::exception& e) {
17670       {
17671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17672       };
17673     } catch (Dali::DaliException e) {
17674       {
17675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17676       };
17677     } catch (...) {
17678       {
17679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17680       };
17681     }
17682   }
17683
17684   jresult = result;
17685   return jresult;
17686 }
17687
17688
17689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17690   unsigned int jresult ;
17691   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17692   Dali::Matrix *arg2 = 0 ;
17693   bool result;
17694
17695   arg1 = (Dali::Property::Value *)jarg1;
17696   arg2 = (Dali::Matrix *)jarg2;
17697   if (!arg2) {
17698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17699     return 0;
17700   }
17701   {
17702     try {
17703       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17704     } catch (std::out_of_range& e) {
17705       {
17706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17707       };
17708     } catch (std::exception& e) {
17709       {
17710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17711       };
17712     } catch (Dali::DaliException e) {
17713       {
17714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17715       };
17716     } catch (...) {
17717       {
17718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17719       };
17720     }
17721   }
17722
17723   jresult = result;
17724   return jresult;
17725 }
17726
17727
17728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17729   unsigned int jresult ;
17730   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17731   Dali::AngleAxis *arg2 = 0 ;
17732   bool result;
17733
17734   arg1 = (Dali::Property::Value *)jarg1;
17735   arg2 = (Dali::AngleAxis *)jarg2;
17736   if (!arg2) {
17737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17738     return 0;
17739   }
17740   {
17741     try {
17742       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17743     } catch (std::out_of_range& e) {
17744       {
17745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (std::exception& e) {
17748       {
17749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17750       };
17751     } catch (Dali::DaliException e) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17754       };
17755     } catch (...) {
17756       {
17757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17758       };
17759     }
17760   }
17761
17762   jresult = result;
17763   return jresult;
17764 }
17765
17766
17767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17768   unsigned int jresult ;
17769   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17770   Dali::Quaternion *arg2 = 0 ;
17771   bool result;
17772
17773   arg1 = (Dali::Property::Value *)jarg1;
17774   arg2 = (Dali::Quaternion *)jarg2;
17775   if (!arg2) {
17776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17777     return 0;
17778   }
17779   {
17780     try {
17781       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17782     } catch (std::out_of_range& e) {
17783       {
17784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17785       };
17786     } catch (std::exception& e) {
17787       {
17788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17789       };
17790     } catch (Dali::DaliException e) {
17791       {
17792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17793       };
17794     } catch (...) {
17795       {
17796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17797       };
17798     }
17799   }
17800
17801   jresult = result;
17802   return jresult;
17803 }
17804
17805
17806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17807   unsigned int jresult ;
17808   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17809   std::string *arg2 = 0 ;
17810   bool result;
17811
17812   arg1 = (Dali::Property::Value *)jarg1;
17813
17814   //typemap in
17815   std::string temp;
17816   arg2 = &temp;
17817
17818   {
17819     try {
17820       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17821     } catch (std::out_of_range& e) {
17822       {
17823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (std::exception& e) {
17826       {
17827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17828       };
17829     } catch (Dali::DaliException e) {
17830       {
17831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17832       };
17833     } catch (...) {
17834       {
17835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17836       };
17837     }
17838   }
17839
17840   jresult = result;
17841
17842   //Typemap argout in c++ file.
17843   //This will convert c++ string to c# string
17844   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17845
17846   return jresult;
17847 }
17848
17849
17850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17851   unsigned int jresult ;
17852   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17853   Dali::Property::Array *arg2 = 0 ;
17854   bool result;
17855
17856   arg1 = (Dali::Property::Value *)jarg1;
17857   arg2 = (Dali::Property::Array *)jarg2;
17858   if (!arg2) {
17859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17860     return 0;
17861   }
17862   {
17863     try {
17864       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17865     } catch (std::out_of_range& e) {
17866       {
17867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17868       };
17869     } catch (std::exception& e) {
17870       {
17871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17872       };
17873     } catch (Dali::DaliException e) {
17874       {
17875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17876       };
17877     } catch (...) {
17878       {
17879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17880       };
17881     }
17882   }
17883
17884   jresult = result;
17885   return jresult;
17886 }
17887
17888
17889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17890   unsigned int jresult ;
17891   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17892   Dali::Property::Map *arg2 = 0 ;
17893   bool result;
17894
17895   arg1 = (Dali::Property::Value *)jarg1;
17896   arg2 = (Dali::Property::Map *)jarg2;
17897   if (!arg2) {
17898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17899     return 0;
17900   }
17901   {
17902     try {
17903       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17904     } catch (std::out_of_range& e) {
17905       {
17906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17907       };
17908     } catch (std::exception& e) {
17909       {
17910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17911       };
17912     } catch (Dali::DaliException e) {
17913       {
17914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17915       };
17916     } catch (...) {
17917       {
17918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17919       };
17920     }
17921   }
17922
17923   jresult = result;
17924   return jresult;
17925 }
17926
17927
17928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17929   unsigned int jresult ;
17930   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17931   Extents *arg2 = 0 ;
17932   bool result;
17933
17934   arg1 = (Dali::Property::Value *)jarg1;
17935   arg2 = (Extents *)jarg2;
17936   if (!arg2) {
17937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17938     return 0;
17939   }
17940   {
17941     try {
17942       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17943     } catch (std::out_of_range& e) {
17944       {
17945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17946       };
17947     } catch (std::exception& e) {
17948       {
17949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17950       };
17951     } catch (...) {
17952       {
17953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17954       };
17955     }
17956   }
17957   jresult = result;
17958   return jresult;
17959 }
17960
17961
17962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17963   void * jresult ;
17964   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17965   Dali::Property::Array *result = 0 ;
17966
17967   arg1 = (Dali::Property::Value *)jarg1;
17968   {
17969     try {
17970       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17971     } catch (std::out_of_range& e) {
17972       {
17973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17974       };
17975     } catch (std::exception& e) {
17976       {
17977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17978       };
17979     } catch (Dali::DaliException e) {
17980       {
17981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17982       };
17983     } catch (...) {
17984       {
17985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17986       };
17987     }
17988   }
17989
17990   jresult = (void *)result;
17991   return jresult;
17992 }
17993
17994
17995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17996   void * jresult ;
17997   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17998   Dali::Property::Map *result = 0 ;
17999
18000   arg1 = (Dali::Property::Value *)jarg1;
18001   {
18002     try {
18003       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18004     } catch (std::out_of_range& e) {
18005       {
18006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18007       };
18008     } catch (std::exception& e) {
18009       {
18010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18011       };
18012     } catch (Dali::DaliException e) {
18013       {
18014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18015       };
18016     } catch (...) {
18017       {
18018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18019       };
18020     }
18021   }
18022
18023   jresult = (void *)result;
18024   return jresult;
18025 }
18026
18027
18028 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18029   char * jresult ;
18030   Dali::Property::Type arg1 ;
18031   char *result = 0 ;
18032
18033   arg1 = (Dali::Property::Type)jarg1;
18034   {
18035     try {
18036       result = (char *)Dali::PropertyTypes::GetName(arg1);
18037     } catch (std::out_of_range& e) {
18038       {
18039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18040       };
18041     } catch (std::exception& e) {
18042       {
18043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18044       };
18045     } catch (Dali::DaliException e) {
18046       {
18047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18048       };
18049     } catch (...) {
18050       {
18051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18052       };
18053     }
18054   }
18055
18056   jresult = SWIG_csharp_string_callback((const char *)result);
18057   return jresult;
18058 }
18059
18060
18061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18062   unsigned int jresult ;
18063   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18064   std::string *arg2 = 0 ;
18065   Dali::Property::Map *arg3 = 0 ;
18066   bool result;
18067
18068   arg1 = (Dali::BaseObject *)jarg1;
18069   if (!jarg2) {
18070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18071     return 0;
18072   }
18073   std::string arg2_str(jarg2);
18074   arg2 = &arg2_str;
18075   arg3 = (Dali::Property::Map *)jarg3;
18076   if (!arg3) {
18077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18078     return 0;
18079   }
18080   {
18081     try {
18082       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18083     } catch (std::out_of_range& e) {
18084       {
18085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18086       };
18087     } catch (std::exception& e) {
18088       {
18089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18090       };
18091     } catch (Dali::DaliException e) {
18092       {
18093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18094       };
18095     } catch (...) {
18096       {
18097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18098       };
18099     }
18100   }
18101
18102   jresult = result;
18103
18104   //argout typemap for const std::string&
18105
18106   return jresult;
18107 }
18108
18109
18110 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18111   char * jresult ;
18112   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18113   std::string *result = 0 ;
18114
18115   arg1 = (Dali::BaseObject *)jarg1;
18116   {
18117     try {
18118       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18119     } catch (std::out_of_range& e) {
18120       {
18121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18122       };
18123     } catch (std::exception& e) {
18124       {
18125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18126       };
18127     } catch (Dali::DaliException e) {
18128       {
18129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18130       };
18131     } catch (...) {
18132       {
18133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18134       };
18135     }
18136   }
18137
18138   jresult = SWIG_csharp_string_callback(result->c_str());
18139   return jresult;
18140 }
18141
18142
18143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18144   unsigned int jresult ;
18145   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18146   Dali::TypeInfo *arg2 = 0 ;
18147   bool result;
18148
18149   arg1 = (Dali::BaseObject *)jarg1;
18150   arg2 = (Dali::TypeInfo *)jarg2;
18151   if (!arg2) {
18152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18153     return 0;
18154   }
18155   {
18156     try {
18157       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18158     } catch (std::out_of_range& e) {
18159       {
18160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18161       };
18162     } catch (std::exception& e) {
18163       {
18164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18165       };
18166     } catch (Dali::DaliException e) {
18167       {
18168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18169       };
18170     } catch (...) {
18171       {
18172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18173       };
18174     }
18175   }
18176
18177   jresult = result;
18178   return jresult;
18179 }
18180
18181
18182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18183   unsigned int jresult ;
18184   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18185   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18186   std::string *arg3 = 0 ;
18187   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18188   bool result;
18189
18190   arg1 = (Dali::BaseObject *)jarg1;
18191   arg2 = (ConnectionTrackerInterface *)jarg2;
18192   if (!jarg3) {
18193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18194     return 0;
18195   }
18196   std::string arg3_str(jarg3);
18197   arg3 = &arg3_str;
18198   arg4 = (FunctorDelegate *)jarg4;
18199   {
18200     try {
18201       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18202     } catch (std::out_of_range& e) {
18203       {
18204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18205       };
18206     } catch (std::exception& e) {
18207       {
18208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18209       };
18210     } catch (Dali::DaliException e) {
18211       {
18212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18213       };
18214     } catch (...) {
18215       {
18216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18217       };
18218     }
18219   }
18220
18221   jresult = result;
18222
18223   //argout typemap for const std::string&
18224
18225   return jresult;
18226 }
18227
18228
18229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18230   void * jresult ;
18231   Dali::BaseHandle *arg1 = 0 ;
18232   Dali::BaseObject *result = 0 ;
18233
18234   arg1 = (Dali::BaseHandle *)jarg1;
18235   if (!arg1) {
18236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18237     return 0;
18238   }
18239   {
18240     try {
18241       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18242     } catch (std::out_of_range& e) {
18243       {
18244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18245       };
18246     } catch (std::exception& e) {
18247       {
18248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18249       };
18250     } catch (Dali::DaliException e) {
18251       {
18252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18253       };
18254     } catch (...) {
18255       {
18256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18257       };
18258     }
18259   }
18260
18261   jresult = (void *)result;
18262   return jresult;
18263 }
18264
18265
18266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18267   void * jresult ;
18268   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18269   Dali::BaseHandle *result = 0 ;
18270
18271   arg1 = (Dali::BaseObject *)jarg1;
18272   {
18273     try {
18274       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18275     } catch (std::out_of_range& e) {
18276       {
18277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18278       };
18279     } catch (std::exception& e) {
18280       {
18281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18282       };
18283     } catch (Dali::DaliException e) {
18284       {
18285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18286       };
18287     } catch (...) {
18288       {
18289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18290       };
18291     }
18292   }
18293
18294   jresult = (void *)result;
18295   return jresult;
18296 }
18297
18298
18299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18300   void * jresult ;
18301   Dali::BaseHandle *result = 0 ;
18302
18303   {
18304     try {
18305       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18306     } catch (std::out_of_range& e) {
18307       {
18308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18309       };
18310     } catch (std::exception& e) {
18311       {
18312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18313       };
18314     } catch (Dali::DaliException e) {
18315       {
18316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18317       };
18318     } catch (...) {
18319       {
18320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18321       };
18322     }
18323   }
18324
18325   jresult = (void *)result;
18326   return jresult;
18327 }
18328
18329
18330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18331   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18332
18333   arg1 = (Dali::BaseHandle *)jarg1;
18334   {
18335     try {
18336       delete arg1;
18337     } catch (std::out_of_range& e) {
18338       {
18339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18340       };
18341     } catch (std::exception& e) {
18342       {
18343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18344       };
18345     } catch (Dali::DaliException e) {
18346       {
18347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18348       };
18349     } catch (...) {
18350       {
18351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18352       };
18353     }
18354   }
18355
18356 }
18357
18358
18359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18360   void * jresult ;
18361   Dali::BaseHandle *arg1 = 0 ;
18362   Dali::BaseHandle *result = 0 ;
18363
18364   arg1 = (Dali::BaseHandle *)jarg1;
18365   if (!arg1) {
18366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18367     return 0;
18368   }
18369   {
18370     try {
18371       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18372     } catch (std::out_of_range& e) {
18373       {
18374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18375       };
18376     } catch (std::exception& e) {
18377       {
18378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18379       };
18380     } catch (Dali::DaliException e) {
18381       {
18382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18383       };
18384     } catch (...) {
18385       {
18386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18387       };
18388     }
18389   }
18390
18391   jresult = (void *)result;
18392   return jresult;
18393 }
18394
18395
18396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18397   void * jresult ;
18398   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18399   Dali::BaseHandle *arg2 = 0 ;
18400   Dali::BaseHandle *result = 0 ;
18401
18402   arg1 = (Dali::BaseHandle *)jarg1;
18403   arg2 = (Dali::BaseHandle *)jarg2;
18404   if (!arg2) {
18405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18406     return 0;
18407   }
18408   {
18409     try {
18410       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18411     } catch (std::out_of_range& e) {
18412       {
18413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18414       };
18415     } catch (std::exception& e) {
18416       {
18417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18418       };
18419     } catch (Dali::DaliException e) {
18420       {
18421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18422       };
18423     } catch (...) {
18424       {
18425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18426       };
18427     }
18428   }
18429
18430   jresult = (void *)result;
18431   return jresult;
18432 }
18433
18434
18435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18436   unsigned int jresult ;
18437   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18438   std::string *arg2 = 0 ;
18439   Dali::Property::Map *arg3 = 0 ;
18440   bool result;
18441
18442   arg1 = (Dali::BaseHandle *)jarg1;
18443   if (!jarg2) {
18444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18445     return 0;
18446   }
18447   std::string arg2_str(jarg2);
18448   arg2 = &arg2_str;
18449   arg3 = (Dali::Property::Map *)jarg3;
18450   if (!arg3) {
18451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18452     return 0;
18453   }
18454   {
18455     try {
18456       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18457     } catch (std::out_of_range& e) {
18458       {
18459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18460       };
18461     } catch (std::exception& e) {
18462       {
18463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18464       };
18465     } catch (Dali::DaliException e) {
18466       {
18467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18468       };
18469     } catch (...) {
18470       {
18471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18472       };
18473     }
18474   }
18475
18476   jresult = result;
18477
18478   //argout typemap for const std::string&
18479
18480   return jresult;
18481 }
18482
18483
18484 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18485   char * jresult ;
18486   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18487   std::string *result = 0 ;
18488
18489   arg1 = (Dali::BaseHandle *)jarg1;
18490   {
18491     try {
18492       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18493     } catch (std::out_of_range& e) {
18494       {
18495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18496       };
18497     } catch (std::exception& e) {
18498       {
18499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18500       };
18501     } catch (Dali::DaliException e) {
18502       {
18503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18504       };
18505     } catch (...) {
18506       {
18507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18508       };
18509     }
18510   }
18511
18512   jresult = SWIG_csharp_string_callback(result->c_str());
18513   return jresult;
18514 }
18515
18516
18517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18518   unsigned int jresult ;
18519   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18520   Dali::TypeInfo *arg2 = 0 ;
18521   bool result;
18522
18523   arg1 = (Dali::BaseHandle *)jarg1;
18524   arg2 = (Dali::TypeInfo *)jarg2;
18525   if (!arg2) {
18526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18527     return 0;
18528   }
18529   {
18530     try {
18531       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18532     } catch (std::out_of_range& e) {
18533       {
18534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18535       };
18536     } catch (std::exception& e) {
18537       {
18538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18539       };
18540     } catch (Dali::DaliException e) {
18541       {
18542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18543       };
18544     } catch (...) {
18545       {
18546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18547       };
18548     }
18549   }
18550
18551   jresult = result;
18552   return jresult;
18553 }
18554
18555
18556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18557   void * jresult ;
18558   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18559   Dali::BaseObject *result = 0 ;
18560
18561   arg1 = (Dali::BaseHandle *)jarg1;
18562   {
18563     try {
18564       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18565     } catch (std::out_of_range& e) {
18566       {
18567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18568       };
18569     } catch (std::exception& e) {
18570       {
18571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18572       };
18573     } catch (Dali::DaliException e) {
18574       {
18575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18576       };
18577     } catch (...) {
18578       {
18579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18580       };
18581     }
18582   }
18583
18584   jresult = (void *)result;
18585   return jresult;
18586 }
18587
18588
18589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18590   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18591
18592   arg1 = (Dali::BaseHandle *)jarg1;
18593   {
18594     try {
18595       (arg1)->Reset();
18596     } catch (std::out_of_range& e) {
18597       {
18598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18599       };
18600     } catch (std::exception& e) {
18601       {
18602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18603       };
18604     } catch (Dali::DaliException e) {
18605       {
18606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18607       };
18608     } catch (...) {
18609       {
18610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18611       };
18612     }
18613   }
18614
18615 }
18616
18617
18618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18619   unsigned int jresult ;
18620   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18621   Dali::BaseHandle *arg2 = 0 ;
18622   bool result;
18623
18624   arg1 = (Dali::BaseHandle *)jarg1;
18625   arg2 = (Dali::BaseHandle *)jarg2;
18626   if (!arg2) {
18627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18628     return 0;
18629   }
18630   {
18631     try {
18632       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18633     } catch (std::out_of_range& e) {
18634       {
18635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18636       };
18637     } catch (std::exception& e) {
18638       {
18639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18640       };
18641     } catch (Dali::DaliException e) {
18642       {
18643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18644       };
18645     } catch (...) {
18646       {
18647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18648       };
18649     }
18650   }
18651
18652   jresult = result;
18653   return jresult;
18654 }
18655
18656
18657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18658   unsigned int jresult ;
18659   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18660   Dali::BaseHandle *arg2 = 0 ;
18661   bool result;
18662
18663   arg1 = (Dali::BaseHandle *)jarg1;
18664   arg2 = (Dali::BaseHandle *)jarg2;
18665   if (!arg2) {
18666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18667     return 0;
18668   }
18669   {
18670     try {
18671       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18672     } catch (std::out_of_range& e) {
18673       {
18674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18675       };
18676     } catch (std::exception& e) {
18677       {
18678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18679       };
18680     } catch (Dali::DaliException e) {
18681       {
18682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18683       };
18684     } catch (...) {
18685       {
18686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18687       };
18688     }
18689   }
18690
18691   jresult = result;
18692   return jresult;
18693 }
18694
18695
18696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18697   void * jresult ;
18698   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18699   Dali::RefObject *result = 0 ;
18700
18701   arg1 = (Dali::BaseHandle *)jarg1;
18702   {
18703     try {
18704       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18705     } catch (std::out_of_range& e) {
18706       {
18707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18708       };
18709     } catch (std::exception& e) {
18710       {
18711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18712       };
18713     } catch (Dali::DaliException e) {
18714       {
18715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18716       };
18717     } catch (...) {
18718       {
18719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18720       };
18721     }
18722   }
18723
18724   jresult = (void *)result;
18725   return jresult;
18726 }
18727
18728
18729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18730   unsigned int jresult ;
18731   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18732   bool result;
18733
18734   arg1 = (Dali::BaseHandle *)jarg1;
18735   {
18736     try {
18737       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18738     } catch (std::out_of_range& e) {
18739       {
18740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18741       };
18742     } catch (std::exception& e) {
18743       {
18744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18745       };
18746     } catch (Dali::DaliException e) {
18747       {
18748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18749       };
18750     } catch (...) {
18751       {
18752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18753       };
18754     }
18755   }
18756
18757   jresult = result;
18758   return jresult;
18759 }
18760
18761
18762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18763   unsigned int jresult ;
18764   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18765   Dali::BaseHandle *arg2 = 0 ;
18766   bool result;
18767
18768   arg1 = (Dali::BaseHandle *)jarg1;
18769   arg2 = (Dali::BaseHandle *)jarg2;
18770   if (!arg2) {
18771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18772     return 0;
18773   }
18774   {
18775     try {
18776       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18777     } catch (std::out_of_range& e) {
18778       {
18779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18780       };
18781     } catch (std::exception& e) {
18782       {
18783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18784       };
18785     } catch (Dali::DaliException e) {
18786       {
18787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18788       };
18789     } catch (...) {
18790       {
18791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18792       };
18793     }
18794   }
18795
18796   jresult = result;
18797   return jresult;
18798 }
18799
18800
18801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18802   unsigned int jresult ;
18803   Dali::BaseHandle *arg1 = 0 ;
18804   Dali::BaseHandle *arg2 = 0 ;
18805   bool result;
18806
18807   arg1 = (Dali::BaseHandle *)jarg1;
18808   if (!arg1) {
18809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18810     return 0;
18811   }
18812   arg2 = (Dali::BaseHandle *)jarg2;
18813   if (!arg2) {
18814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18815     return 0;
18816   }
18817   {
18818     try {
18819       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18820     } catch (std::out_of_range& e) {
18821       {
18822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18823       };
18824     } catch (std::exception& e) {
18825       {
18826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18827       };
18828     } catch (Dali::DaliException e) {
18829       {
18830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18831       };
18832     } catch (...) {
18833       {
18834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18835       };
18836     }
18837   }
18838
18839   jresult = result;
18840   return jresult;
18841 }
18842
18843
18844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18845   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18846
18847   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18848   {
18849     try {
18850       delete arg1;
18851     } catch (std::out_of_range& e) {
18852       {
18853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18854       };
18855     } catch (std::exception& e) {
18856       {
18857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18858       };
18859     } catch (Dali::DaliException e) {
18860       {
18861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18862       };
18863     } catch (...) {
18864       {
18865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18866       };
18867     }
18868   }
18869
18870 }
18871
18872
18873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18874   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18875   SlotObserver *arg2 = (SlotObserver *) 0 ;
18876   CallbackBase *arg3 = (CallbackBase *) 0 ;
18877
18878   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18879   arg2 = (SlotObserver *)jarg2;
18880   arg3 = (CallbackBase *)jarg3;
18881   {
18882     try {
18883       (arg1)->SignalConnected(arg2,arg3);
18884     } catch (std::out_of_range& e) {
18885       {
18886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18887       };
18888     } catch (std::exception& e) {
18889       {
18890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18891       };
18892     } catch (Dali::DaliException e) {
18893       {
18894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18895       };
18896     } catch (...) {
18897       {
18898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18899       };
18900     }
18901   }
18902
18903 }
18904
18905
18906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18907   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18908
18909   arg1 = (Dali::SignalObserver *)jarg1;
18910   {
18911     try {
18912       delete arg1;
18913     } catch (std::out_of_range& e) {
18914       {
18915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18916       };
18917     } catch (std::exception& e) {
18918       {
18919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18920       };
18921     } catch (Dali::DaliException e) {
18922       {
18923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18924       };
18925     } catch (...) {
18926       {
18927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18928       };
18929     }
18930   }
18931
18932 }
18933
18934
18935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18936   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18937   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18938   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18939
18940   arg1 = (Dali::SignalObserver *)jarg1;
18941   arg2 = (Dali::SlotObserver *)jarg2;
18942   arg3 = (Dali::CallbackBase *)jarg3;
18943   {
18944     try {
18945       (arg1)->SignalDisconnected(arg2,arg3);
18946     } catch (std::out_of_range& e) {
18947       {
18948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18949       };
18950     } catch (std::exception& e) {
18951       {
18952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18953       };
18954     } catch (Dali::DaliException e) {
18955       {
18956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18957       };
18958     } catch (...) {
18959       {
18960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18961       };
18962     }
18963   }
18964
18965 }
18966
18967
18968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18969   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18970
18971   arg1 = (Dali::SlotObserver *)jarg1;
18972   {
18973     try {
18974       delete arg1;
18975     } catch (std::out_of_range& e) {
18976       {
18977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18978       };
18979     } catch (std::exception& e) {
18980       {
18981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18982       };
18983     } catch (Dali::DaliException e) {
18984       {
18985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18986       };
18987     } catch (...) {
18988       {
18989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18990       };
18991     }
18992   }
18993
18994 }
18995
18996
18997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18998   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18999   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19000
19001   arg1 = (Dali::SlotObserver *)jarg1;
19002   arg2 = (Dali::CallbackBase *)jarg2;
19003   {
19004     try {
19005       (arg1)->SlotDisconnected(arg2);
19006     } catch (std::out_of_range& e) {
19007       {
19008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19009       };
19010     } catch (std::exception& e) {
19011       {
19012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19013       };
19014     } catch (Dali::DaliException e) {
19015       {
19016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19017       };
19018     } catch (...) {
19019       {
19020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19021       };
19022     }
19023   }
19024
19025 }
19026
19027
19028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19029   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19030
19031   arg1 = (Dali::ConnectionTracker *)jarg1;
19032   {
19033     try {
19034       delete arg1;
19035     } catch (std::out_of_range& e) {
19036       {
19037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19038       };
19039     } catch (std::exception& e) {
19040       {
19041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19042       };
19043     } catch (Dali::DaliException e) {
19044       {
19045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19046       };
19047     } catch (...) {
19048       {
19049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19050       };
19051     }
19052   }
19053
19054 }
19055
19056
19057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19058   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19059
19060   arg1 = (Dali::ConnectionTracker *)jarg1;
19061   {
19062     try {
19063       (arg1)->DisconnectAll();
19064     } catch (std::out_of_range& e) {
19065       {
19066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19067       };
19068     } catch (std::exception& e) {
19069       {
19070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19071       };
19072     } catch (Dali::DaliException e) {
19073       {
19074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19075       };
19076     } catch (...) {
19077       {
19078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19079       };
19080     }
19081   }
19082
19083 }
19084
19085
19086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19087   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19088   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19089   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19090
19091   arg1 = (Dali::ConnectionTracker *)jarg1;
19092   arg2 = (Dali::SlotObserver *)jarg2;
19093   arg3 = (Dali::CallbackBase *)jarg3;
19094   {
19095     try {
19096       (arg1)->SignalConnected(arg2,arg3);
19097     } catch (std::out_of_range& e) {
19098       {
19099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19100       };
19101     } catch (std::exception& e) {
19102       {
19103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19104       };
19105     } catch (Dali::DaliException e) {
19106       {
19107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19108       };
19109     } catch (...) {
19110       {
19111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19112       };
19113     }
19114   }
19115
19116 }
19117
19118
19119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19120   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19121   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19122   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19123
19124   arg1 = (Dali::ConnectionTracker *)jarg1;
19125   arg2 = (Dali::SlotObserver *)jarg2;
19126   arg3 = (Dali::CallbackBase *)jarg3;
19127   {
19128     try {
19129       (arg1)->SignalDisconnected(arg2,arg3);
19130     } catch (std::out_of_range& e) {
19131       {
19132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19133       };
19134     } catch (std::exception& e) {
19135       {
19136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19137       };
19138     } catch (Dali::DaliException e) {
19139       {
19140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19141       };
19142     } catch (...) {
19143       {
19144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19145       };
19146     }
19147   }
19148
19149 }
19150
19151
19152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19153   unsigned long jresult ;
19154   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19155   std::size_t result;
19156
19157   arg1 = (Dali::ConnectionTracker *)jarg1;
19158   {
19159     try {
19160       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19161     } catch (std::out_of_range& e) {
19162       {
19163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19164       };
19165     } catch (std::exception& e) {
19166       {
19167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19168       };
19169     } catch (Dali::DaliException e) {
19170       {
19171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19172       };
19173     } catch (...) {
19174       {
19175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19176       };
19177     }
19178   }
19179
19180   jresult = (unsigned long)result;
19181   return jresult;
19182 }
19183
19184
19185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19186   void * jresult ;
19187   Dali::ObjectRegistry *result = 0 ;
19188
19189   {
19190     try {
19191       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19192     } catch (std::out_of_range& e) {
19193       {
19194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19195       };
19196     } catch (std::exception& e) {
19197       {
19198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19199       };
19200     } catch (Dali::DaliException e) {
19201       {
19202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19203       };
19204     } catch (...) {
19205       {
19206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19207       };
19208     }
19209   }
19210
19211   jresult = (void *)result;
19212   return jresult;
19213 }
19214
19215
19216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19217   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19218
19219   arg1 = (Dali::ObjectRegistry *)jarg1;
19220   {
19221     try {
19222       delete arg1;
19223     } catch (std::out_of_range& e) {
19224       {
19225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19226       };
19227     } catch (std::exception& e) {
19228       {
19229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19230       };
19231     } catch (Dali::DaliException e) {
19232       {
19233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19234       };
19235     } catch (...) {
19236       {
19237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19238       };
19239     }
19240   }
19241
19242 }
19243
19244
19245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19246   void * jresult ;
19247   Dali::ObjectRegistry *arg1 = 0 ;
19248   Dali::ObjectRegistry *result = 0 ;
19249
19250   arg1 = (Dali::ObjectRegistry *)jarg1;
19251   if (!arg1) {
19252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19253     return 0;
19254   }
19255   {
19256     try {
19257       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19258     } catch (std::out_of_range& e) {
19259       {
19260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19261       };
19262     } catch (std::exception& e) {
19263       {
19264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19265       };
19266     } catch (Dali::DaliException e) {
19267       {
19268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19269       };
19270     } catch (...) {
19271       {
19272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19273       };
19274     }
19275   }
19276
19277   jresult = (void *)result;
19278   return jresult;
19279 }
19280
19281
19282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19283   void * jresult ;
19284   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19285   Dali::ObjectRegistry *arg2 = 0 ;
19286   Dali::ObjectRegistry *result = 0 ;
19287
19288   arg1 = (Dali::ObjectRegistry *)jarg1;
19289   arg2 = (Dali::ObjectRegistry *)jarg2;
19290   if (!arg2) {
19291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19292     return 0;
19293   }
19294   {
19295     try {
19296       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19297     } catch (std::out_of_range& e) {
19298       {
19299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19300       };
19301     } catch (std::exception& e) {
19302       {
19303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19304       };
19305     } catch (Dali::DaliException e) {
19306       {
19307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19308       };
19309     } catch (...) {
19310       {
19311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19312       };
19313     }
19314   }
19315
19316   jresult = (void *)result;
19317   return jresult;
19318 }
19319
19320
19321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19322   void * jresult ;
19323   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19324   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19325
19326   arg1 = (Dali::ObjectRegistry *)jarg1;
19327   {
19328     try {
19329       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19330     } catch (std::out_of_range& e) {
19331       {
19332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19333       };
19334     } catch (std::exception& e) {
19335       {
19336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19337       };
19338     } catch (Dali::DaliException e) {
19339       {
19340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19341       };
19342     } catch (...) {
19343       {
19344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19345       };
19346     }
19347   }
19348
19349   jresult = (void *)result;
19350   return jresult;
19351 }
19352
19353
19354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19355   void * jresult ;
19356   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19357   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19358
19359   arg1 = (Dali::ObjectRegistry *)jarg1;
19360   {
19361     try {
19362       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19363     } catch (std::out_of_range& e) {
19364       {
19365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19366       };
19367     } catch (std::exception& e) {
19368       {
19369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19370       };
19371     } catch (Dali::DaliException e) {
19372       {
19373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19374       };
19375     } catch (...) {
19376       {
19377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19378       };
19379     }
19380   }
19381
19382   jresult = (void *)result;
19383   return jresult;
19384 }
19385
19386
19387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19388   void * jresult ;
19389   Dali::PropertyCondition *result = 0 ;
19390
19391   {
19392     try {
19393       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19394     } catch (std::out_of_range& e) {
19395       {
19396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19397       };
19398     } catch (std::exception& e) {
19399       {
19400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19401       };
19402     } catch (Dali::DaliException e) {
19403       {
19404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19405       };
19406     } catch (...) {
19407       {
19408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19409       };
19410     }
19411   }
19412
19413   jresult = (void *)result;
19414   return jresult;
19415 }
19416
19417
19418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19419   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19420
19421   arg1 = (Dali::PropertyCondition *)jarg1;
19422   {
19423     try {
19424       delete arg1;
19425     } catch (std::out_of_range& e) {
19426       {
19427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19428       };
19429     } catch (std::exception& e) {
19430       {
19431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19432       };
19433     } catch (Dali::DaliException e) {
19434       {
19435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19436       };
19437     } catch (...) {
19438       {
19439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19440       };
19441     }
19442   }
19443
19444 }
19445
19446
19447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19448   void * jresult ;
19449   Dali::PropertyCondition *arg1 = 0 ;
19450   Dali::PropertyCondition *result = 0 ;
19451
19452   arg1 = (Dali::PropertyCondition *)jarg1;
19453   if (!arg1) {
19454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19455     return 0;
19456   }
19457   {
19458     try {
19459       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19460     } catch (std::out_of_range& e) {
19461       {
19462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19463       };
19464     } catch (std::exception& e) {
19465       {
19466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19467       };
19468     } catch (Dali::DaliException e) {
19469       {
19470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19471       };
19472     } catch (...) {
19473       {
19474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19475       };
19476     }
19477   }
19478
19479   jresult = (void *)result;
19480   return jresult;
19481 }
19482
19483
19484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19485   void * jresult ;
19486   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19487   Dali::PropertyCondition *arg2 = 0 ;
19488   Dali::PropertyCondition *result = 0 ;
19489
19490   arg1 = (Dali::PropertyCondition *)jarg1;
19491   arg2 = (Dali::PropertyCondition *)jarg2;
19492   if (!arg2) {
19493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19494     return 0;
19495   }
19496   {
19497     try {
19498       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19499     } catch (std::out_of_range& e) {
19500       {
19501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19502       };
19503     } catch (std::exception& e) {
19504       {
19505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19506       };
19507     } catch (Dali::DaliException e) {
19508       {
19509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19510       };
19511     } catch (...) {
19512       {
19513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19514       };
19515     }
19516   }
19517
19518   jresult = (void *)result;
19519   return jresult;
19520 }
19521
19522
19523 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19524   unsigned long jresult ;
19525   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19526   std::size_t result;
19527
19528   arg1 = (Dali::PropertyCondition *)jarg1;
19529   {
19530     try {
19531       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19532     } catch (std::out_of_range& e) {
19533       {
19534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19535       };
19536     } catch (std::exception& e) {
19537       {
19538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19539       };
19540     } catch (...) {
19541       {
19542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19543       };
19544     }
19545   }
19546   jresult = (unsigned long)result;
19547   return jresult;
19548 }
19549
19550
19551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19552   float jresult ;
19553   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19554   std::size_t arg2 ;
19555   float result;
19556
19557   arg1 = (Dali::PropertyCondition *)jarg1;
19558   arg2 = (std::size_t)jarg2;
19559   {
19560     try {
19561       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19562     } catch (std::out_of_range& e) {
19563       {
19564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19565       };
19566     } catch (std::exception& e) {
19567       {
19568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19569       };
19570     } catch (...) {
19571       {
19572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19573       };
19574     }
19575   }
19576   jresult = result;
19577   return jresult;
19578 }
19579
19580
19581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19582   void * jresult ;
19583   float arg1 ;
19584   Dali::PropertyCondition result;
19585
19586   arg1 = (float)jarg1;
19587   {
19588     try {
19589       result = Dali::LessThanCondition(arg1);
19590     } catch (std::out_of_range& e) {
19591       {
19592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19593       };
19594     } catch (std::exception& e) {
19595       {
19596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19597       };
19598     } catch (Dali::DaliException e) {
19599       {
19600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19601       };
19602     } catch (...) {
19603       {
19604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19605       };
19606     }
19607   }
19608
19609   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19610   return jresult;
19611 }
19612
19613
19614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19615   void * jresult ;
19616   float arg1 ;
19617   Dali::PropertyCondition result;
19618
19619   arg1 = (float)jarg1;
19620   {
19621     try {
19622       result = Dali::GreaterThanCondition(arg1);
19623     } catch (std::out_of_range& e) {
19624       {
19625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19626       };
19627     } catch (std::exception& e) {
19628       {
19629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19630       };
19631     } catch (Dali::DaliException e) {
19632       {
19633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19634       };
19635     } catch (...) {
19636       {
19637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19638       };
19639     }
19640   }
19641
19642   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19643   return jresult;
19644 }
19645
19646
19647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19648   void * jresult ;
19649   float arg1 ;
19650   float arg2 ;
19651   Dali::PropertyCondition result;
19652
19653   arg1 = (float)jarg1;
19654   arg2 = (float)jarg2;
19655   {
19656     try {
19657       result = Dali::InsideCondition(arg1,arg2);
19658     } catch (std::out_of_range& e) {
19659       {
19660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19661       };
19662     } catch (std::exception& e) {
19663       {
19664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19665       };
19666     } catch (Dali::DaliException e) {
19667       {
19668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19669       };
19670     } catch (...) {
19671       {
19672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19673       };
19674     }
19675   }
19676
19677   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19678   return jresult;
19679 }
19680
19681
19682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19683   void * jresult ;
19684   float arg1 ;
19685   float arg2 ;
19686   Dali::PropertyCondition result;
19687
19688   arg1 = (float)jarg1;
19689   arg2 = (float)jarg2;
19690   {
19691     try {
19692       result = Dali::OutsideCondition(arg1,arg2);
19693     } catch (std::out_of_range& e) {
19694       {
19695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19696       };
19697     } catch (std::exception& e) {
19698       {
19699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19700       };
19701     } catch (Dali::DaliException e) {
19702       {
19703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19704       };
19705     } catch (...) {
19706       {
19707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19708       };
19709     }
19710   }
19711
19712   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19713   return jresult;
19714 }
19715
19716
19717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19718   void * jresult ;
19719   float arg1 ;
19720   float arg2 ;
19721   Dali::PropertyCondition result;
19722
19723   arg1 = (float)jarg1;
19724   arg2 = (float)jarg2;
19725   {
19726     try {
19727       result = Dali::StepCondition(arg1,arg2);
19728     } catch (std::out_of_range& e) {
19729       {
19730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19731       };
19732     } catch (std::exception& e) {
19733       {
19734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19735       };
19736     } catch (Dali::DaliException e) {
19737       {
19738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19739       };
19740     } catch (...) {
19741       {
19742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19743       };
19744     }
19745   }
19746
19747   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19748   return jresult;
19749 }
19750
19751
19752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19753   void * jresult ;
19754   float arg1 ;
19755   Dali::PropertyCondition result;
19756
19757   arg1 = (float)jarg1;
19758   {
19759     try {
19760       result = Dali::StepCondition(arg1);
19761     } catch (std::out_of_range& e) {
19762       {
19763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19764       };
19765     } catch (std::exception& e) {
19766       {
19767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19768       };
19769     } catch (Dali::DaliException e) {
19770       {
19771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19772       };
19773     } catch (...) {
19774       {
19775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19776       };
19777     }
19778   }
19779
19780   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19781   return jresult;
19782 }
19783
19784
19785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19786   void * jresult ;
19787   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19788   Dali::PropertyCondition result;
19789
19790   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19791   if (!arg1) {
19792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19793     return 0;
19794   }
19795   {
19796     try {
19797       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19798     } catch (std::out_of_range& e) {
19799       {
19800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19801       };
19802     } catch (std::exception& e) {
19803       {
19804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19805       };
19806     } catch (Dali::DaliException e) {
19807       {
19808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19809       };
19810     } catch (...) {
19811       {
19812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19813       };
19814     }
19815   }
19816
19817   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19818   return jresult;
19819 }
19820
19821
19822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19823   void * jresult ;
19824   Dali::PropertyNotification *result = 0 ;
19825
19826   {
19827     try {
19828       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19829     } catch (std::out_of_range& e) {
19830       {
19831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19832       };
19833     } catch (std::exception& e) {
19834       {
19835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19836       };
19837     } catch (Dali::DaliException e) {
19838       {
19839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19840       };
19841     } catch (...) {
19842       {
19843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19844       };
19845     }
19846   }
19847
19848   jresult = (void *)result;
19849   return jresult;
19850 }
19851
19852
19853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19854   void * jresult ;
19855   Dali::BaseHandle arg1 ;
19856   Dali::BaseHandle *argp1 ;
19857   Dali::PropertyNotification result;
19858
19859   argp1 = (Dali::BaseHandle *)jarg1;
19860   if (!argp1) {
19861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19862     return 0;
19863   }
19864   arg1 = *argp1;
19865   {
19866     try {
19867       result = Dali::PropertyNotification::DownCast(arg1);
19868     } catch (std::out_of_range& e) {
19869       {
19870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19871       };
19872     } catch (std::exception& e) {
19873       {
19874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19875       };
19876     } catch (Dali::DaliException e) {
19877       {
19878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19879       };
19880     } catch (...) {
19881       {
19882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19883       };
19884     }
19885   }
19886
19887   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19888   return jresult;
19889 }
19890
19891
19892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19893   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19894
19895   arg1 = (Dali::PropertyNotification *)jarg1;
19896   {
19897     try {
19898       delete arg1;
19899     } catch (std::out_of_range& e) {
19900       {
19901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19902       };
19903     } catch (std::exception& e) {
19904       {
19905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19906       };
19907     } catch (Dali::DaliException e) {
19908       {
19909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19910       };
19911     } catch (...) {
19912       {
19913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19914       };
19915     }
19916   }
19917
19918 }
19919
19920
19921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19922   void * jresult ;
19923   Dali::PropertyNotification *arg1 = 0 ;
19924   Dali::PropertyNotification *result = 0 ;
19925
19926   arg1 = (Dali::PropertyNotification *)jarg1;
19927   if (!arg1) {
19928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19929     return 0;
19930   }
19931   {
19932     try {
19933       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19934     } catch (std::out_of_range& e) {
19935       {
19936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19937       };
19938     } catch (std::exception& e) {
19939       {
19940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19941       };
19942     } catch (Dali::DaliException e) {
19943       {
19944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19945       };
19946     } catch (...) {
19947       {
19948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19949       };
19950     }
19951   }
19952
19953   jresult = (void *)result;
19954   return jresult;
19955 }
19956
19957
19958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19959   void * jresult ;
19960   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19961   Dali::PropertyNotification *arg2 = 0 ;
19962   Dali::PropertyNotification *result = 0 ;
19963
19964   arg1 = (Dali::PropertyNotification *)jarg1;
19965   arg2 = (Dali::PropertyNotification *)jarg2;
19966   if (!arg2) {
19967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19968     return 0;
19969   }
19970   {
19971     try {
19972       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19973     } catch (std::out_of_range& e) {
19974       {
19975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19976       };
19977     } catch (std::exception& e) {
19978       {
19979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19980       };
19981     } catch (Dali::DaliException e) {
19982       {
19983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19984       };
19985     } catch (...) {
19986       {
19987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19988       };
19989     }
19990   }
19991
19992   jresult = (void *)result;
19993   return jresult;
19994 }
19995
19996
19997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19998   void * jresult ;
19999   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20000   Dali::PropertyCondition result;
20001
20002   arg1 = (Dali::PropertyNotification *)jarg1;
20003   {
20004     try {
20005       result = (arg1)->GetCondition();
20006     } catch (std::out_of_range& e) {
20007       {
20008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20009       };
20010     } catch (std::exception& e) {
20011       {
20012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20013       };
20014     } catch (Dali::DaliException e) {
20015       {
20016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20017       };
20018     } catch (...) {
20019       {
20020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20021       };
20022     }
20023   }
20024
20025   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20026   return jresult;
20027 }
20028
20029
20030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20031   void * jresult ;
20032   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20033   Dali::Handle result;
20034
20035   arg1 = (Dali::PropertyNotification *)jarg1;
20036   {
20037     try {
20038       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20039     } catch (std::out_of_range& e) {
20040       {
20041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20042       };
20043     } catch (std::exception& e) {
20044       {
20045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20046       };
20047     } catch (Dali::DaliException e) {
20048       {
20049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20050       };
20051     } catch (...) {
20052       {
20053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20054       };
20055     }
20056   }
20057
20058   jresult = new Dali::Handle((const Dali::Handle &)result);
20059   return jresult;
20060 }
20061
20062
20063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20064   int jresult ;
20065   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20066   Dali::Property::Index result;
20067
20068   arg1 = (Dali::PropertyNotification *)jarg1;
20069   {
20070     try {
20071       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20072     } catch (std::out_of_range& e) {
20073       {
20074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20075       };
20076     } catch (std::exception& e) {
20077       {
20078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20079       };
20080     } catch (Dali::DaliException e) {
20081       {
20082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20083       };
20084     } catch (...) {
20085       {
20086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20087       };
20088     }
20089   }
20090
20091   jresult = result;
20092   return jresult;
20093 }
20094
20095
20096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20097   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20098   Dali::PropertyNotification::NotifyMode arg2 ;
20099
20100   arg1 = (Dali::PropertyNotification *)jarg1;
20101   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20102   {
20103     try {
20104       (arg1)->SetNotifyMode(arg2);
20105     } catch (std::out_of_range& e) {
20106       {
20107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20108       };
20109     } catch (std::exception& e) {
20110       {
20111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20112       };
20113     } catch (Dali::DaliException e) {
20114       {
20115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20116       };
20117     } catch (...) {
20118       {
20119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20120       };
20121     }
20122   }
20123
20124 }
20125
20126
20127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20128   int jresult ;
20129   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20130   Dali::PropertyNotification::NotifyMode result;
20131
20132   arg1 = (Dali::PropertyNotification *)jarg1;
20133   {
20134     try {
20135       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20136     } catch (std::out_of_range& e) {
20137       {
20138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20139       };
20140     } catch (std::exception& e) {
20141       {
20142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20143       };
20144     } catch (Dali::DaliException e) {
20145       {
20146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20147       };
20148     } catch (...) {
20149       {
20150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20151       };
20152     }
20153   }
20154
20155   jresult = (int)result;
20156   return jresult;
20157 }
20158
20159
20160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20161   unsigned int jresult ;
20162   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20163   bool result;
20164
20165   arg1 = (Dali::PropertyNotification *)jarg1;
20166   {
20167     try {
20168       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20169     } catch (std::out_of_range& e) {
20170       {
20171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20172       };
20173     } catch (std::exception& e) {
20174       {
20175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20176       };
20177     } catch (Dali::DaliException e) {
20178       {
20179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20180       };
20181     } catch (...) {
20182       {
20183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20184       };
20185     }
20186   }
20187
20188   jresult = result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20194   void * jresult ;
20195   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20196   Dali::PropertyNotifySignalType *result = 0 ;
20197
20198   arg1 = (Dali::PropertyNotification *)jarg1;
20199   {
20200     try {
20201       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20202     } catch (std::out_of_range& e) {
20203       {
20204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20205       };
20206     } catch (std::exception& e) {
20207       {
20208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20209       };
20210     } catch (Dali::DaliException e) {
20211       {
20212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20213       };
20214     } catch (...) {
20215       {
20216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20217       };
20218     }
20219   }
20220
20221   jresult = (void *)result;
20222   return jresult;
20223 }
20224
20225
20226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20227   void * jresult ;
20228   Dali::Handle *result = 0 ;
20229
20230   {
20231     try {
20232       result = (Dali::Handle *)new Dali::Handle();
20233     } catch (std::out_of_range& e) {
20234       {
20235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20236       };
20237     } catch (std::exception& e) {
20238       {
20239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20240       };
20241     } catch (Dali::DaliException e) {
20242       {
20243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20244       };
20245     } catch (...) {
20246       {
20247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20248       };
20249     }
20250   }
20251
20252   jresult = (void *)result;
20253   return jresult;
20254 }
20255
20256
20257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20258   void * jresult ;
20259   Dali::Handle result;
20260
20261   {
20262     try {
20263       result = Dali::Handle::New();
20264     } catch (std::out_of_range& e) {
20265       {
20266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20267       };
20268     } catch (std::exception& e) {
20269       {
20270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20271       };
20272     } catch (Dali::DaliException e) {
20273       {
20274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20275       };
20276     } catch (...) {
20277       {
20278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20279       };
20280     }
20281   }
20282
20283   jresult = new Dali::Handle((const Dali::Handle &)result);
20284   return jresult;
20285 }
20286
20287
20288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20289   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20290
20291   arg1 = (Dali::Handle *)jarg1;
20292   {
20293     try {
20294       delete arg1;
20295     } catch (std::out_of_range& e) {
20296       {
20297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20298       };
20299     } catch (std::exception& e) {
20300       {
20301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20302       };
20303     } catch (Dali::DaliException e) {
20304       {
20305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20306       };
20307     } catch (...) {
20308       {
20309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20310       };
20311     }
20312   }
20313
20314 }
20315
20316
20317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20318   void * jresult ;
20319   Dali::Handle *arg1 = 0 ;
20320   Dali::Handle *result = 0 ;
20321
20322   arg1 = (Dali::Handle *)jarg1;
20323   if (!arg1) {
20324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20325     return 0;
20326   }
20327   {
20328     try {
20329       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20330     } catch (std::out_of_range& e) {
20331       {
20332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20333       };
20334     } catch (std::exception& e) {
20335       {
20336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20337       };
20338     } catch (Dali::DaliException e) {
20339       {
20340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20341       };
20342     } catch (...) {
20343       {
20344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20345       };
20346     }
20347   }
20348
20349   jresult = (void *)result;
20350   return jresult;
20351 }
20352
20353
20354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20355   void * jresult ;
20356   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20357   Dali::Handle *arg2 = 0 ;
20358   Dali::Handle *result = 0 ;
20359
20360   arg1 = (Dali::Handle *)jarg1;
20361   arg2 = (Dali::Handle *)jarg2;
20362   if (!arg2) {
20363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20364     return 0;
20365   }
20366   {
20367     try {
20368       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20369     } catch (std::out_of_range& e) {
20370       {
20371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20372       };
20373     } catch (std::exception& e) {
20374       {
20375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20376       };
20377     } catch (Dali::DaliException e) {
20378       {
20379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20380       };
20381     } catch (...) {
20382       {
20383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20384       };
20385     }
20386   }
20387
20388   jresult = (void *)result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20394   void * jresult ;
20395   Dali::BaseHandle arg1 ;
20396   Dali::BaseHandle *argp1 ;
20397   Dali::Handle result;
20398
20399   argp1 = (Dali::BaseHandle *)jarg1;
20400   if (!argp1) {
20401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20402     return 0;
20403   }
20404   arg1 = *argp1;
20405   {
20406     try {
20407       result = Dali::Handle::DownCast(arg1);
20408     } catch (std::out_of_range& e) {
20409       {
20410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20411       };
20412     } catch (std::exception& e) {
20413       {
20414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20415       };
20416     } catch (Dali::DaliException e) {
20417       {
20418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20419       };
20420     } catch (...) {
20421       {
20422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20423       };
20424     }
20425   }
20426
20427   jresult = new Dali::Handle((const Dali::Handle &)result);
20428   return jresult;
20429 }
20430
20431
20432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20433   unsigned int jresult ;
20434   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20435   Dali::Handle::Capability arg2 ;
20436   bool result;
20437
20438   arg1 = (Dali::Handle *)jarg1;
20439   arg2 = (Dali::Handle::Capability)jarg2;
20440   {
20441     try {
20442       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20443     } catch (std::out_of_range& e) {
20444       {
20445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20446       };
20447     } catch (std::exception& e) {
20448       {
20449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20450       };
20451     } catch (Dali::DaliException e) {
20452       {
20453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20454       };
20455     } catch (...) {
20456       {
20457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20458       };
20459     }
20460   }
20461
20462   jresult = result;
20463   return jresult;
20464 }
20465
20466
20467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20468   unsigned int jresult ;
20469   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20470   unsigned int result;
20471
20472   arg1 = (Dali::Handle *)jarg1;
20473   {
20474     try {
20475       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20476     } catch (std::out_of_range& e) {
20477       {
20478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20479       };
20480     } catch (std::exception& e) {
20481       {
20482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20483       };
20484     } catch (Dali::DaliException e) {
20485       {
20486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20487       };
20488     } catch (...) {
20489       {
20490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20491       };
20492     }
20493   }
20494
20495   jresult = result;
20496   return jresult;
20497 }
20498
20499
20500 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20501   char * jresult ;
20502   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20503   Dali::Property::Index arg2 ;
20504   std::string result;
20505
20506   arg1 = (Dali::Handle *)jarg1;
20507   arg2 = (Dali::Property::Index)jarg2;
20508   {
20509     try {
20510       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20511     } catch (std::out_of_range& e) {
20512       {
20513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20514       };
20515     } catch (std::exception& e) {
20516       {
20517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20518       };
20519     } catch (Dali::DaliException e) {
20520       {
20521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20522       };
20523     } catch (...) {
20524       {
20525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20526       };
20527     }
20528   }
20529
20530   jresult = SWIG_csharp_string_callback((&result)->c_str());
20531   return jresult;
20532 }
20533
20534
20535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20536   int jresult ;
20537   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20538   std::string *arg2 = 0 ;
20539   Dali::Property::Index result;
20540
20541   arg1 = (Dali::Handle *)jarg1;
20542   if (!jarg2) {
20543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20544     return 0;
20545   }
20546   std::string arg2_str(jarg2);
20547   arg2 = &arg2_str;
20548   {
20549     try {
20550       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20551     } catch (std::out_of_range& e) {
20552       {
20553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20554       };
20555     } catch (std::exception& e) {
20556       {
20557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20558       };
20559     } catch (Dali::DaliException e) {
20560       {
20561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20562       };
20563     } catch (...) {
20564       {
20565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20566       };
20567     }
20568   }
20569
20570   jresult = result;
20571
20572   //argout typemap for const std::string&
20573
20574   return jresult;
20575 }
20576
20577
20578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20579   unsigned int jresult ;
20580   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20581   Dali::Property::Index arg2 ;
20582   bool result;
20583
20584   arg1 = (Dali::Handle *)jarg1;
20585   arg2 = (Dali::Property::Index)jarg2;
20586   {
20587     try {
20588       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20589     } catch (std::out_of_range& e) {
20590       {
20591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20592       };
20593     } catch (std::exception& e) {
20594       {
20595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20596       };
20597     } catch (Dali::DaliException e) {
20598       {
20599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20600       };
20601     } catch (...) {
20602       {
20603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20604       };
20605     }
20606   }
20607
20608   jresult = result;
20609   return jresult;
20610 }
20611
20612
20613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20614   unsigned int jresult ;
20615   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20616   Dali::Property::Index arg2 ;
20617   bool result;
20618
20619   arg1 = (Dali::Handle *)jarg1;
20620   arg2 = (Dali::Property::Index)jarg2;
20621   {
20622     try {
20623       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20624     } catch (std::out_of_range& e) {
20625       {
20626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20627       };
20628     } catch (std::exception& e) {
20629       {
20630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20631       };
20632     } catch (Dali::DaliException e) {
20633       {
20634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20635       };
20636     } catch (...) {
20637       {
20638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20639       };
20640     }
20641   }
20642
20643   jresult = result;
20644   return jresult;
20645 }
20646
20647
20648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20649   unsigned int jresult ;
20650   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20651   Dali::Property::Index arg2 ;
20652   bool result;
20653
20654   arg1 = (Dali::Handle *)jarg1;
20655   arg2 = (Dali::Property::Index)jarg2;
20656   {
20657     try {
20658       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20659     } catch (std::out_of_range& e) {
20660       {
20661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20662       };
20663     } catch (std::exception& e) {
20664       {
20665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20666       };
20667     } catch (Dali::DaliException e) {
20668       {
20669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20670       };
20671     } catch (...) {
20672       {
20673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20674       };
20675     }
20676   }
20677
20678   jresult = result;
20679   return jresult;
20680 }
20681
20682
20683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20684   int jresult ;
20685   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20686   Dali::Property::Index arg2 ;
20687   Dali::Property::Type result;
20688
20689   arg1 = (Dali::Handle *)jarg1;
20690   arg2 = (Dali::Property::Index)jarg2;
20691   {
20692     try {
20693       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20694     } catch (std::out_of_range& e) {
20695       {
20696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20697       };
20698     } catch (std::exception& e) {
20699       {
20700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20701       };
20702     } catch (Dali::DaliException e) {
20703       {
20704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20705       };
20706     } catch (...) {
20707       {
20708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20709       };
20710     }
20711   }
20712
20713   jresult = (int)result;
20714   return jresult;
20715 }
20716
20717
20718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20719   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20720   Dali::Property::Index arg2 ;
20721   Dali::Property::Value *arg3 = 0 ;
20722
20723   arg1 = (Dali::Handle *)jarg1;
20724   arg2 = (Dali::Property::Index)jarg2;
20725   arg3 = (Dali::Property::Value *)jarg3;
20726   if (!arg3) {
20727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20728     return ;
20729   }
20730   {
20731     try {
20732       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20733     } catch (std::out_of_range& e) {
20734       {
20735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20736       };
20737     } catch (std::exception& e) {
20738       {
20739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20740       };
20741     } catch (Dali::DaliException e) {
20742       {
20743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20744       };
20745     } catch (...) {
20746       {
20747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20748       };
20749     }
20750   }
20751
20752 }
20753
20754
20755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20756   int jresult ;
20757   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20758   std::string *arg2 = 0 ;
20759   Dali::Property::Value *arg3 = 0 ;
20760   Dali::Property::Index result;
20761
20762   arg1 = (Dali::Handle *)jarg1;
20763   if (!jarg2) {
20764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20765     return 0;
20766   }
20767   std::string arg2_str(jarg2);
20768   arg2 = &arg2_str;
20769   arg3 = (Dali::Property::Value *)jarg3;
20770   if (!arg3) {
20771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20772     return 0;
20773   }
20774   {
20775     try {
20776       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20777     } catch (std::out_of_range& e) {
20778       {
20779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20780       };
20781     } catch (std::exception& e) {
20782       {
20783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20784       };
20785     } catch (Dali::DaliException e) {
20786       {
20787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20788       };
20789     } catch (...) {
20790       {
20791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20792       };
20793     }
20794   }
20795
20796   jresult = result;
20797
20798   //argout typemap for const std::string&
20799
20800   return jresult;
20801 }
20802
20803
20804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20805   int jresult ;
20806   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20807   std::string *arg2 = 0 ;
20808   Dali::Property::Value *arg3 = 0 ;
20809   Dali::Property::AccessMode arg4 ;
20810   Dali::Property::Index result;
20811
20812   arg1 = (Dali::Handle *)jarg1;
20813   if (!jarg2) {
20814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20815     return 0;
20816   }
20817   std::string arg2_str(jarg2);
20818   arg2 = &arg2_str;
20819   arg3 = (Dali::Property::Value *)jarg3;
20820   if (!arg3) {
20821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20822     return 0;
20823   }
20824   arg4 = (Dali::Property::AccessMode)jarg4;
20825   {
20826     try {
20827       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20828     } catch (std::out_of_range& e) {
20829       {
20830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20831       };
20832     } catch (std::exception& e) {
20833       {
20834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20835       };
20836     } catch (Dali::DaliException e) {
20837       {
20838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20839       };
20840     } catch (...) {
20841       {
20842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20843       };
20844     }
20845   }
20846
20847   jresult = result;
20848
20849   //argout typemap for const std::string&
20850
20851   return jresult;
20852 }
20853
20854
20855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20856   void * jresult ;
20857   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20858   Dali::Property::Index arg2 ;
20859   Dali::Property::Value result;
20860
20861   arg1 = (Dali::Handle *)jarg1;
20862   arg2 = (Dali::Property::Index)jarg2;
20863   {
20864     try {
20865       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20866     } catch (std::out_of_range& e) {
20867       {
20868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20869       };
20870     } catch (std::exception& e) {
20871       {
20872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20873       };
20874     } catch (Dali::DaliException e) {
20875       {
20876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20877       };
20878     } catch (...) {
20879       {
20880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20881       };
20882     }
20883   }
20884
20885   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20886   return jresult;
20887 }
20888
20889
20890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20891   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20892   Dali::Property::IndexContainer *arg2 = 0 ;
20893
20894   arg1 = (Dali::Handle *)jarg1;
20895   arg2 = (Dali::Property::IndexContainer *)jarg2;
20896   if (!arg2) {
20897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20898     return ;
20899   }
20900   {
20901     try {
20902       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20903     } catch (std::out_of_range& e) {
20904       {
20905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20906       };
20907     } catch (std::exception& e) {
20908       {
20909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20910       };
20911     } catch (Dali::DaliException e) {
20912       {
20913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20914       };
20915     } catch (...) {
20916       {
20917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20918       };
20919     }
20920   }
20921
20922 }
20923
20924
20925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20926   void * jresult ;
20927   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20928   Dali::Property::Index arg2 ;
20929   Dali::PropertyCondition *arg3 = 0 ;
20930   Dali::PropertyNotification result;
20931
20932   arg1 = (Dali::Handle *)jarg1;
20933   arg2 = (Dali::Property::Index)jarg2;
20934   arg3 = (Dali::PropertyCondition *)jarg3;
20935   if (!arg3) {
20936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20937     return 0;
20938   }
20939   {
20940     try {
20941       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20942     } catch (std::out_of_range& e) {
20943       {
20944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20945       };
20946     } catch (std::exception& e) {
20947       {
20948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20949       };
20950     } catch (Dali::DaliException e) {
20951       {
20952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20953       };
20954     } catch (...) {
20955       {
20956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20957       };
20958     }
20959   }
20960
20961   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20962   return jresult;
20963 }
20964
20965
20966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20967   void * jresult ;
20968   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20969   Dali::Property::Index arg2 ;
20970   int arg3 ;
20971   Dali::PropertyCondition *arg4 = 0 ;
20972   Dali::PropertyNotification result;
20973
20974   arg1 = (Dali::Handle *)jarg1;
20975   arg2 = (Dali::Property::Index)jarg2;
20976   arg3 = (int)jarg3;
20977   arg4 = (Dali::PropertyCondition *)jarg4;
20978   if (!arg4) {
20979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20980     return 0;
20981   }
20982   {
20983     try {
20984       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20985     } catch (std::out_of_range& e) {
20986       {
20987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20988       };
20989     } catch (std::exception& e) {
20990       {
20991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20992       };
20993     } catch (Dali::DaliException e) {
20994       {
20995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20996       };
20997     } catch (...) {
20998       {
20999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21000       };
21001     }
21002   }
21003
21004   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21005   return jresult;
21006 }
21007
21008
21009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21010   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21011   Dali::PropertyNotification arg2 ;
21012   Dali::PropertyNotification *argp2 ;
21013
21014   arg1 = (Dali::Handle *)jarg1;
21015   argp2 = (Dali::PropertyNotification *)jarg2;
21016   if (!argp2) {
21017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21018     return ;
21019   }
21020   arg2 = *argp2;
21021   {
21022     try {
21023       (arg1)->RemovePropertyNotification(arg2);
21024     } catch (std::out_of_range& e) {
21025       {
21026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21027       };
21028     } catch (std::exception& e) {
21029       {
21030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21031       };
21032     } catch (Dali::DaliException e) {
21033       {
21034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21035       };
21036     } catch (...) {
21037       {
21038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21039       };
21040     }
21041   }
21042
21043 }
21044
21045
21046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21047   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21048
21049   arg1 = (Dali::Handle *)jarg1;
21050   {
21051     try {
21052       (arg1)->RemovePropertyNotifications();
21053     } catch (std::out_of_range& e) {
21054       {
21055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21056       };
21057     } catch (std::exception& e) {
21058       {
21059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21060       };
21061     } catch (Dali::DaliException e) {
21062       {
21063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21064       };
21065     } catch (...) {
21066       {
21067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21068       };
21069     }
21070   }
21071
21072 }
21073
21074
21075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21076   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21077
21078   arg1 = (Dali::Handle *)jarg1;
21079   {
21080     try {
21081       (arg1)->RemoveConstraints();
21082     } catch (std::out_of_range& e) {
21083       {
21084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21085       };
21086     } catch (std::exception& e) {
21087       {
21088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21089       };
21090     } catch (Dali::DaliException e) {
21091       {
21092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21093       };
21094     } catch (...) {
21095       {
21096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21097       };
21098     }
21099   }
21100
21101 }
21102
21103
21104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21105   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21106   unsigned int arg2 ;
21107
21108   arg1 = (Dali::Handle *)jarg1;
21109   arg2 = (unsigned int)jarg2;
21110   {
21111     try {
21112       (arg1)->RemoveConstraints(arg2);
21113     } catch (std::out_of_range& e) {
21114       {
21115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21116       };
21117     } catch (std::exception& e) {
21118       {
21119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21120       };
21121     } catch (Dali::DaliException e) {
21122       {
21123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21124       };
21125     } catch (...) {
21126       {
21127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21128       };
21129     }
21130   }
21131
21132 }
21133
21134
21135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21136   int jresult ;
21137   Dali::Property::Index result;
21138
21139   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21140   jresult = result;
21141   return jresult;
21142 }
21143
21144
21145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21146   void * jresult ;
21147   Dali::Handle result;
21148
21149   {
21150     try {
21151       result = Dali::WeightObject::New();
21152     } catch (std::out_of_range& e) {
21153       {
21154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21155       };
21156     } catch (std::exception& e) {
21157       {
21158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21159       };
21160     } catch (Dali::DaliException e) {
21161       {
21162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21163       };
21164     } catch (...) {
21165       {
21166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21167       };
21168     }
21169   }
21170
21171   jresult = new Dali::Handle((const Dali::Handle &)result);
21172   return jresult;
21173 }
21174
21175
21176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21177   void * jresult ;
21178   Dali::TypeInfo *result = 0 ;
21179
21180   {
21181     try {
21182       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21183     } catch (std::out_of_range& e) {
21184       {
21185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21186       };
21187     } catch (std::exception& e) {
21188       {
21189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21190       };
21191     } catch (Dali::DaliException e) {
21192       {
21193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21194       };
21195     } catch (...) {
21196       {
21197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21198       };
21199     }
21200   }
21201
21202   jresult = (void *)result;
21203   return jresult;
21204 }
21205
21206
21207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21208   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21209
21210   arg1 = (Dali::TypeInfo *)jarg1;
21211   {
21212     try {
21213       delete arg1;
21214     } catch (std::out_of_range& e) {
21215       {
21216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21217       };
21218     } catch (std::exception& e) {
21219       {
21220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21221       };
21222     } catch (Dali::DaliException e) {
21223       {
21224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21225       };
21226     } catch (...) {
21227       {
21228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21229       };
21230     }
21231   }
21232
21233 }
21234
21235
21236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21237   void * jresult ;
21238   Dali::TypeInfo *arg1 = 0 ;
21239   Dali::TypeInfo *result = 0 ;
21240
21241   arg1 = (Dali::TypeInfo *)jarg1;
21242   if (!arg1) {
21243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21244     return 0;
21245   }
21246   {
21247     try {
21248       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21249     } catch (std::out_of_range& e) {
21250       {
21251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21252       };
21253     } catch (std::exception& e) {
21254       {
21255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21256       };
21257     } catch (Dali::DaliException e) {
21258       {
21259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21260       };
21261     } catch (...) {
21262       {
21263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21264       };
21265     }
21266   }
21267
21268   jresult = (void *)result;
21269   return jresult;
21270 }
21271
21272
21273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21274   void * jresult ;
21275   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21276   Dali::TypeInfo *arg2 = 0 ;
21277   Dali::TypeInfo *result = 0 ;
21278
21279   arg1 = (Dali::TypeInfo *)jarg1;
21280   arg2 = (Dali::TypeInfo *)jarg2;
21281   if (!arg2) {
21282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21283     return 0;
21284   }
21285   {
21286     try {
21287       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21288     } catch (std::out_of_range& e) {
21289       {
21290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21291       };
21292     } catch (std::exception& e) {
21293       {
21294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21295       };
21296     } catch (Dali::DaliException e) {
21297       {
21298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21299       };
21300     } catch (...) {
21301       {
21302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21303       };
21304     }
21305   }
21306
21307   jresult = (void *)result;
21308   return jresult;
21309 }
21310
21311
21312 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21313   char * jresult ;
21314   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21315   std::string *result = 0 ;
21316
21317   arg1 = (Dali::TypeInfo *)jarg1;
21318   {
21319     try {
21320       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21321     } catch (std::out_of_range& e) {
21322       {
21323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21324       };
21325     } catch (std::exception& e) {
21326       {
21327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21328       };
21329     } catch (Dali::DaliException e) {
21330       {
21331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21332       };
21333     } catch (...) {
21334       {
21335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21336       };
21337     }
21338   }
21339
21340   jresult = SWIG_csharp_string_callback(result->c_str());
21341   return jresult;
21342 }
21343
21344
21345 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21346   char * jresult ;
21347   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21348   std::string *result = 0 ;
21349
21350   arg1 = (Dali::TypeInfo *)jarg1;
21351   {
21352     try {
21353       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21354     } catch (std::out_of_range& e) {
21355       {
21356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21357       };
21358     } catch (std::exception& e) {
21359       {
21360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21361       };
21362     } catch (Dali::DaliException e) {
21363       {
21364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21365       };
21366     } catch (...) {
21367       {
21368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21369       };
21370     }
21371   }
21372
21373   jresult = SWIG_csharp_string_callback(result->c_str());
21374   return jresult;
21375 }
21376
21377
21378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21379   void * jresult ;
21380   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21381   Dali::BaseHandle result;
21382
21383   arg1 = (Dali::TypeInfo *)jarg1;
21384   {
21385     try {
21386       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21387     } catch (std::out_of_range& e) {
21388       {
21389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21390       };
21391     } catch (std::exception& e) {
21392       {
21393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21394       };
21395     } catch (Dali::DaliException e) {
21396       {
21397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21398       };
21399     } catch (...) {
21400       {
21401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21402       };
21403     }
21404   }
21405
21406   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21407   return jresult;
21408 }
21409
21410
21411 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21412   unsigned long jresult ;
21413   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21414   size_t result;
21415
21416   arg1 = (Dali::TypeInfo *)jarg1;
21417   {
21418     try {
21419       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21420     } catch (std::out_of_range& e) {
21421       {
21422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21423       };
21424     } catch (std::exception& e) {
21425       {
21426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21427       };
21428     } catch (Dali::DaliException e) {
21429       {
21430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21431       };
21432     } catch (...) {
21433       {
21434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21435       };
21436     }
21437   }
21438
21439   jresult = (unsigned long)result;
21440   return jresult;
21441 }
21442
21443
21444 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21445   char * jresult ;
21446   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21447   size_t arg2 ;
21448   std::string result;
21449
21450   arg1 = (Dali::TypeInfo *)jarg1;
21451   arg2 = (size_t)jarg2;
21452   {
21453     try {
21454       result = (arg1)->GetActionName(arg2);
21455     } catch (std::out_of_range& e) {
21456       {
21457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21458       };
21459     } catch (std::exception& e) {
21460       {
21461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21462       };
21463     } catch (Dali::DaliException e) {
21464       {
21465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21466       };
21467     } catch (...) {
21468       {
21469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21470       };
21471     }
21472   }
21473
21474   jresult = SWIG_csharp_string_callback((&result)->c_str());
21475   return jresult;
21476 }
21477
21478
21479 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21480   unsigned long jresult ;
21481   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21482   size_t result;
21483
21484   arg1 = (Dali::TypeInfo *)jarg1;
21485   {
21486     try {
21487       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21488     } catch (std::out_of_range& e) {
21489       {
21490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (std::exception& e) {
21493       {
21494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21495       };
21496     } catch (Dali::DaliException e) {
21497       {
21498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21499       };
21500     } catch (...) {
21501       {
21502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21503       };
21504     }
21505   }
21506
21507   jresult = (unsigned long)result;
21508   return jresult;
21509 }
21510
21511
21512 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21513   char * jresult ;
21514   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21515   size_t arg2 ;
21516   std::string result;
21517
21518   arg1 = (Dali::TypeInfo *)jarg1;
21519   arg2 = (size_t)jarg2;
21520   {
21521     try {
21522       result = (arg1)->GetSignalName(arg2);
21523     } catch (std::out_of_range& e) {
21524       {
21525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21526       };
21527     } catch (std::exception& e) {
21528       {
21529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21530       };
21531     } catch (Dali::DaliException e) {
21532       {
21533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21534       };
21535     } catch (...) {
21536       {
21537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21538       };
21539     }
21540   }
21541
21542   jresult = SWIG_csharp_string_callback((&result)->c_str());
21543   return jresult;
21544 }
21545
21546
21547 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21548   unsigned long jresult ;
21549   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21550   size_t result;
21551
21552   arg1 = (Dali::TypeInfo *)jarg1;
21553   {
21554     try {
21555       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21556     } catch (std::out_of_range& e) {
21557       {
21558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21559       };
21560     } catch (std::exception& e) {
21561       {
21562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21563       };
21564     } catch (Dali::DaliException e) {
21565       {
21566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21567       };
21568     } catch (...) {
21569       {
21570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21571       };
21572     }
21573   }
21574
21575   jresult = (unsigned long)result;
21576   return jresult;
21577 }
21578
21579
21580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21581   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21582   Dali::Property::IndexContainer *arg2 = 0 ;
21583
21584   arg1 = (Dali::TypeInfo *)jarg1;
21585   arg2 = (Dali::Property::IndexContainer *)jarg2;
21586   if (!arg2) {
21587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21588     return ;
21589   }
21590   {
21591     try {
21592       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21593     } catch (std::out_of_range& e) {
21594       {
21595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21596       };
21597     } catch (std::exception& e) {
21598       {
21599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21600       };
21601     } catch (Dali::DaliException e) {
21602       {
21603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21604       };
21605     } catch (...) {
21606       {
21607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21608       };
21609     }
21610   }
21611
21612 }
21613
21614
21615 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21616   char * jresult ;
21617   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21618   Dali::Property::Index arg2 ;
21619   std::string *result = 0 ;
21620
21621   arg1 = (Dali::TypeInfo *)jarg1;
21622   arg2 = (Dali::Property::Index)jarg2;
21623   {
21624     try {
21625       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21626     } catch (std::out_of_range& e) {
21627       {
21628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21629       };
21630     } catch (std::exception& e) {
21631       {
21632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21633       };
21634     } catch (Dali::DaliException e) {
21635       {
21636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21637       };
21638     } catch (...) {
21639       {
21640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21641       };
21642     }
21643   }
21644
21645   jresult = SWIG_csharp_string_callback(result->c_str());
21646   return jresult;
21647 }
21648
21649
21650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21651   void * jresult ;
21652   Dali::TypeRegistry result;
21653
21654   {
21655     try {
21656       result = Dali::TypeRegistry::Get();
21657     } catch (std::out_of_range& e) {
21658       {
21659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21660       };
21661     } catch (std::exception& e) {
21662       {
21663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21664       };
21665     } catch (Dali::DaliException e) {
21666       {
21667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21668       };
21669     } catch (...) {
21670       {
21671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21672       };
21673     }
21674   }
21675
21676   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21677   return jresult;
21678 }
21679
21680
21681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21682   void * jresult ;
21683   Dali::TypeRegistry *result = 0 ;
21684
21685   {
21686     try {
21687       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21688     } catch (std::out_of_range& e) {
21689       {
21690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21691       };
21692     } catch (std::exception& e) {
21693       {
21694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21695       };
21696     } catch (Dali::DaliException e) {
21697       {
21698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21699       };
21700     } catch (...) {
21701       {
21702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21703       };
21704     }
21705   }
21706
21707   jresult = (void *)result;
21708   return jresult;
21709 }
21710
21711
21712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21713   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21714
21715   arg1 = (Dali::TypeRegistry *)jarg1;
21716   {
21717     try {
21718       delete arg1;
21719     } catch (std::out_of_range& e) {
21720       {
21721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21722       };
21723     } catch (std::exception& e) {
21724       {
21725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21726       };
21727     } catch (Dali::DaliException e) {
21728       {
21729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21730       };
21731     } catch (...) {
21732       {
21733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21734       };
21735     }
21736   }
21737
21738 }
21739
21740
21741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21742   void * jresult ;
21743   Dali::TypeRegistry *arg1 = 0 ;
21744   Dali::TypeRegistry *result = 0 ;
21745
21746   arg1 = (Dali::TypeRegistry *)jarg1;
21747   if (!arg1) {
21748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21749     return 0;
21750   }
21751   {
21752     try {
21753       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21754     } catch (std::out_of_range& e) {
21755       {
21756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21757       };
21758     } catch (std::exception& e) {
21759       {
21760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21761       };
21762     } catch (Dali::DaliException e) {
21763       {
21764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21765       };
21766     } catch (...) {
21767       {
21768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21769       };
21770     }
21771   }
21772
21773   jresult = (void *)result;
21774   return jresult;
21775 }
21776
21777
21778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21779   void * jresult ;
21780   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21781   Dali::TypeRegistry *arg2 = 0 ;
21782   Dali::TypeRegistry *result = 0 ;
21783
21784   arg1 = (Dali::TypeRegistry *)jarg1;
21785   arg2 = (Dali::TypeRegistry *)jarg2;
21786   if (!arg2) {
21787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21788     return 0;
21789   }
21790   {
21791     try {
21792       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21793     } catch (std::out_of_range& e) {
21794       {
21795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21796       };
21797     } catch (std::exception& e) {
21798       {
21799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21800       };
21801     } catch (Dali::DaliException e) {
21802       {
21803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21804       };
21805     } catch (...) {
21806       {
21807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21808       };
21809     }
21810   }
21811
21812   jresult = (void *)result;
21813   return jresult;
21814 }
21815
21816
21817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21818   void * jresult ;
21819   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21820   std::string *arg2 = 0 ;
21821   Dali::TypeInfo result;
21822
21823   arg1 = (Dali::TypeRegistry *)jarg1;
21824   if (!jarg2) {
21825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21826     return 0;
21827   }
21828   std::string arg2_str(jarg2);
21829   arg2 = &arg2_str;
21830   {
21831     try {
21832       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21833     } catch (std::out_of_range& e) {
21834       {
21835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (std::exception& e) {
21838       {
21839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21840       };
21841     } catch (Dali::DaliException e) {
21842       {
21843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21844       };
21845     } catch (...) {
21846       {
21847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21848       };
21849     }
21850   }
21851
21852   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21853
21854   //argout typemap for const std::string&
21855
21856   return jresult;
21857 }
21858
21859
21860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21861   void * jresult ;
21862   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21863   std::type_info *arg2 = 0 ;
21864   Dali::TypeInfo result;
21865
21866   arg1 = (Dali::TypeRegistry *)jarg1;
21867   arg2 = (std::type_info *)jarg2;
21868   if (!arg2) {
21869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21870     return 0;
21871   }
21872   {
21873     try {
21874       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21875     } catch (std::out_of_range& e) {
21876       {
21877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21878       };
21879     } catch (std::exception& e) {
21880       {
21881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21882       };
21883     } catch (Dali::DaliException e) {
21884       {
21885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21886       };
21887     } catch (...) {
21888       {
21889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21890       };
21891     }
21892   }
21893
21894   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21895   return jresult;
21896 }
21897
21898
21899 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21900   unsigned long jresult ;
21901   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21902   size_t result;
21903
21904   arg1 = (Dali::TypeRegistry *)jarg1;
21905   {
21906     try {
21907       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21908     } catch (std::out_of_range& e) {
21909       {
21910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21911       };
21912     } catch (std::exception& e) {
21913       {
21914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21915       };
21916     } catch (Dali::DaliException e) {
21917       {
21918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21919       };
21920     } catch (...) {
21921       {
21922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21923       };
21924     }
21925   }
21926
21927   jresult = (unsigned long)result;
21928   return jresult;
21929 }
21930
21931
21932 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21933   char * jresult ;
21934   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21935   size_t arg2 ;
21936   std::string result;
21937
21938   arg1 = (Dali::TypeRegistry *)jarg1;
21939   arg2 = (size_t)jarg2;
21940   {
21941     try {
21942       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21943     } catch (std::out_of_range& e) {
21944       {
21945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21946       };
21947     } catch (std::exception& e) {
21948       {
21949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21950       };
21951     } catch (Dali::DaliException e) {
21952       {
21953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21954       };
21955     } catch (...) {
21956       {
21957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21958       };
21959     }
21960   }
21961
21962   jresult = SWIG_csharp_string_callback((&result)->c_str());
21963   return jresult;
21964 }
21965
21966
21967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21968   void * jresult ;
21969   std::type_info *arg1 = 0 ;
21970   std::type_info *arg2 = 0 ;
21971   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21972   Dali::TypeRegistration *result = 0 ;
21973
21974   arg1 = (std::type_info *)jarg1;
21975   if (!arg1) {
21976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21977     return 0;
21978   }
21979   arg2 = (std::type_info *)jarg2;
21980   if (!arg2) {
21981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21982     return 0;
21983   }
21984   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21985   {
21986     try {
21987       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21988     } catch (std::out_of_range& e) {
21989       {
21990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21991       };
21992     } catch (std::exception& e) {
21993       {
21994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21995       };
21996     } catch (Dali::DaliException e) {
21997       {
21998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21999       };
22000     } catch (...) {
22001       {
22002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22003       };
22004     }
22005   }
22006
22007   jresult = (void *)result;
22008   return jresult;
22009 }
22010
22011
22012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22013   void * jresult ;
22014   std::type_info *arg1 = 0 ;
22015   std::type_info *arg2 = 0 ;
22016   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22017   bool arg4 ;
22018   Dali::TypeRegistration *result = 0 ;
22019
22020   arg1 = (std::type_info *)jarg1;
22021   if (!arg1) {
22022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22023     return 0;
22024   }
22025   arg2 = (std::type_info *)jarg2;
22026   if (!arg2) {
22027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22028     return 0;
22029   }
22030   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22031   arg4 = jarg4 ? true : false;
22032   {
22033     try {
22034       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22035     } catch (std::out_of_range& e) {
22036       {
22037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22038       };
22039     } catch (std::exception& e) {
22040       {
22041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22042       };
22043     } catch (Dali::DaliException e) {
22044       {
22045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22046       };
22047     } catch (...) {
22048       {
22049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22050       };
22051     }
22052   }
22053
22054   jresult = (void *)result;
22055   return jresult;
22056 }
22057
22058
22059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22060   void * jresult ;
22061   std::string *arg1 = 0 ;
22062   std::type_info *arg2 = 0 ;
22063   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22064   Dali::TypeRegistration *result = 0 ;
22065
22066   if (!jarg1) {
22067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22068     return 0;
22069   }
22070   std::string arg1_str(jarg1);
22071   arg1 = &arg1_str;
22072   arg2 = (std::type_info *)jarg2;
22073   if (!arg2) {
22074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22075     return 0;
22076   }
22077   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22078   {
22079     try {
22080       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22081     } catch (std::out_of_range& e) {
22082       {
22083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22084       };
22085     } catch (std::exception& e) {
22086       {
22087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22088       };
22089     } catch (Dali::DaliException e) {
22090       {
22091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22092       };
22093     } catch (...) {
22094       {
22095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22096       };
22097     }
22098   }
22099
22100   jresult = (void *)result;
22101
22102   //argout typemap for const std::string&
22103
22104   return jresult;
22105 }
22106
22107
22108 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22109   char * jresult ;
22110   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22111   std::string result;
22112
22113   arg1 = (Dali::TypeRegistration *)jarg1;
22114   {
22115     try {
22116       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22117     } catch (std::out_of_range& e) {
22118       {
22119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22120       };
22121     } catch (std::exception& e) {
22122       {
22123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22124       };
22125     } catch (Dali::DaliException e) {
22126       {
22127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22128       };
22129     } catch (...) {
22130       {
22131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22132       };
22133     }
22134   }
22135
22136   jresult = SWIG_csharp_string_callback((&result)->c_str());
22137   return jresult;
22138 }
22139
22140
22141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22142   std::string *arg1 = 0 ;
22143   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22144
22145   if (!jarg1) {
22146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22147     return ;
22148   }
22149   std::string arg1_str(jarg1);
22150   arg1 = &arg1_str;
22151   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22152   {
22153     try {
22154       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22155     } catch (std::out_of_range& e) {
22156       {
22157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22158       };
22159     } catch (std::exception& e) {
22160       {
22161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22162       };
22163     } catch (Dali::DaliException e) {
22164       {
22165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22166       };
22167     } catch (...) {
22168       {
22169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22170       };
22171     }
22172   }
22173
22174
22175   //argout typemap for const std::string&
22176
22177 }
22178
22179
22180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22181   std::string *arg1 = 0 ;
22182   std::string *arg2 = 0 ;
22183   int arg3 ;
22184   Dali::Property::Type arg4 ;
22185   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22186   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22187
22188   if (!jarg1) {
22189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22190     return ;
22191   }
22192   std::string arg1_str(jarg1);
22193   arg1 = &arg1_str;
22194   if (!jarg2) {
22195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22196     return ;
22197   }
22198   std::string arg2_str(jarg2);
22199   arg2 = &arg2_str;
22200   arg3 = (int)jarg3;
22201   arg4 = (Dali::Property::Type)jarg4;
22202   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22203   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22204   {
22205     try {
22206       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22207     } catch (std::out_of_range& e) {
22208       {
22209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22210       };
22211     } catch (std::exception& e) {
22212       {
22213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22214       };
22215     } catch (Dali::DaliException e) {
22216       {
22217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22218       };
22219     } catch (...) {
22220       {
22221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22222       };
22223     }
22224   }
22225
22226
22227   //argout typemap for const std::string&
22228
22229
22230   //argout typemap for const std::string&
22231
22232 }
22233
22234
22235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22236   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22237
22238   arg1 = (Dali::TypeRegistration *)jarg1;
22239   {
22240     try {
22241       delete arg1;
22242     } catch (std::out_of_range& e) {
22243       {
22244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22245       };
22246     } catch (std::exception& e) {
22247       {
22248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22249       };
22250     } catch (Dali::DaliException e) {
22251       {
22252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22253       };
22254     } catch (...) {
22255       {
22256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22257       };
22258     }
22259   }
22260
22261 }
22262
22263
22264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22265   void * jresult ;
22266   Dali::TypeRegistration *arg1 = 0 ;
22267   std::string *arg2 = 0 ;
22268   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22269   Dali::SignalConnectorType *result = 0 ;
22270
22271   arg1 = (Dali::TypeRegistration *)jarg1;
22272   if (!arg1) {
22273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22274     return 0;
22275   }
22276   if (!jarg2) {
22277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22278     return 0;
22279   }
22280   std::string arg2_str(jarg2);
22281   arg2 = &arg2_str;
22282   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22283   {
22284     try {
22285       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22286     } catch (std::out_of_range& e) {
22287       {
22288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22289       };
22290     } catch (std::exception& e) {
22291       {
22292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22293       };
22294     } catch (Dali::DaliException e) {
22295       {
22296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22297       };
22298     } catch (...) {
22299       {
22300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22301       };
22302     }
22303   }
22304
22305   jresult = (void *)result;
22306
22307   //argout typemap for const std::string&
22308
22309   return jresult;
22310 }
22311
22312
22313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22314   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22315
22316   arg1 = (Dali::SignalConnectorType *)jarg1;
22317   {
22318     try {
22319       delete arg1;
22320     } catch (std::out_of_range& e) {
22321       {
22322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22323       };
22324     } catch (std::exception& e) {
22325       {
22326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22327       };
22328     } catch (Dali::DaliException e) {
22329       {
22330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22331       };
22332     } catch (...) {
22333       {
22334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22335       };
22336     }
22337   }
22338
22339 }
22340
22341
22342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22343   void * jresult ;
22344   Dali::TypeRegistration *arg1 = 0 ;
22345   std::string *arg2 = 0 ;
22346   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22347   Dali::TypeAction *result = 0 ;
22348
22349   arg1 = (Dali::TypeRegistration *)jarg1;
22350   if (!arg1) {
22351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22352     return 0;
22353   }
22354   if (!jarg2) {
22355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22356     return 0;
22357   }
22358   std::string arg2_str(jarg2);
22359   arg2 = &arg2_str;
22360   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22361   {
22362     try {
22363       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22364     } catch (std::out_of_range& e) {
22365       {
22366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22367       };
22368     } catch (std::exception& e) {
22369       {
22370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22371       };
22372     } catch (Dali::DaliException e) {
22373       {
22374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22375       };
22376     } catch (...) {
22377       {
22378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22379       };
22380     }
22381   }
22382
22383   jresult = (void *)result;
22384
22385   //argout typemap for const std::string&
22386
22387   return jresult;
22388 }
22389
22390
22391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22392   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22393
22394   arg1 = (Dali::TypeAction *)jarg1;
22395   {
22396     try {
22397       delete arg1;
22398     } catch (std::out_of_range& e) {
22399       {
22400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22401       };
22402     } catch (std::exception& e) {
22403       {
22404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22405       };
22406     } catch (Dali::DaliException e) {
22407       {
22408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22409       };
22410     } catch (...) {
22411       {
22412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22413       };
22414     }
22415   }
22416
22417 }
22418
22419
22420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22421   void * jresult ;
22422   Dali::TypeRegistration *arg1 = 0 ;
22423   std::string *arg2 = 0 ;
22424   Dali::Property::Index arg3 ;
22425   Dali::Property::Type arg4 ;
22426   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22427   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22428   Dali::PropertyRegistration *result = 0 ;
22429
22430   arg1 = (Dali::TypeRegistration *)jarg1;
22431   if (!arg1) {
22432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22433     return 0;
22434   }
22435   if (!jarg2) {
22436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22437     return 0;
22438   }
22439   std::string arg2_str(jarg2);
22440   arg2 = &arg2_str;
22441   arg3 = (Dali::Property::Index)jarg3;
22442   arg4 = (Dali::Property::Type)jarg4;
22443   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22444   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22445   {
22446     try {
22447       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22448     } catch (std::out_of_range& e) {
22449       {
22450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22451       };
22452     } catch (std::exception& e) {
22453       {
22454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22455       };
22456     } catch (Dali::DaliException e) {
22457       {
22458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22459       };
22460     } catch (...) {
22461       {
22462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22463       };
22464     }
22465   }
22466
22467   jresult = (void *)result;
22468
22469   //argout typemap for const std::string&
22470
22471   return jresult;
22472 }
22473
22474
22475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22476   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22477
22478   arg1 = (Dali::PropertyRegistration *)jarg1;
22479   {
22480     try {
22481       delete arg1;
22482     } catch (std::out_of_range& e) {
22483       {
22484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22485       };
22486     } catch (std::exception& e) {
22487       {
22488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22489       };
22490     } catch (Dali::DaliException e) {
22491       {
22492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22493       };
22494     } catch (...) {
22495       {
22496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22497       };
22498     }
22499   }
22500
22501 }
22502
22503
22504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22505   void * jresult ;
22506   Dali::TypeRegistration *arg1 = 0 ;
22507   std::string *arg2 = 0 ;
22508   Dali::Property::Index arg3 ;
22509   Dali::Property::Type arg4 ;
22510   Dali::AnimatablePropertyRegistration *result = 0 ;
22511
22512   arg1 = (Dali::TypeRegistration *)jarg1;
22513   if (!arg1) {
22514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22515     return 0;
22516   }
22517   if (!jarg2) {
22518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22519     return 0;
22520   }
22521   std::string arg2_str(jarg2);
22522   arg2 = &arg2_str;
22523   arg3 = (Dali::Property::Index)jarg3;
22524   arg4 = (Dali::Property::Type)jarg4;
22525   {
22526     try {
22527       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22528     } catch (std::out_of_range& e) {
22529       {
22530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22531       };
22532     } catch (std::exception& e) {
22533       {
22534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22535       };
22536     } catch (Dali::DaliException e) {
22537       {
22538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22539       };
22540     } catch (...) {
22541       {
22542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22543       };
22544     }
22545   }
22546
22547   jresult = (void *)result;
22548
22549   //argout typemap for const std::string&
22550
22551   return jresult;
22552 }
22553
22554
22555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22556   void * jresult ;
22557   Dali::TypeRegistration *arg1 = 0 ;
22558   std::string *arg2 = 0 ;
22559   Dali::Property::Index arg3 ;
22560   Dali::Property::Value *arg4 = 0 ;
22561   Dali::AnimatablePropertyRegistration *result = 0 ;
22562
22563   arg1 = (Dali::TypeRegistration *)jarg1;
22564   if (!arg1) {
22565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22566     return 0;
22567   }
22568   if (!jarg2) {
22569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22570     return 0;
22571   }
22572   std::string arg2_str(jarg2);
22573   arg2 = &arg2_str;
22574   arg3 = (Dali::Property::Index)jarg3;
22575   arg4 = (Dali::Property::Value *)jarg4;
22576   if (!arg4) {
22577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22578     return 0;
22579   }
22580   {
22581     try {
22582       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22583     } catch (std::out_of_range& e) {
22584       {
22585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22586       };
22587     } catch (std::exception& e) {
22588       {
22589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22590       };
22591     } catch (Dali::DaliException e) {
22592       {
22593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22594       };
22595     } catch (...) {
22596       {
22597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22598       };
22599     }
22600   }
22601
22602   jresult = (void *)result;
22603
22604   //argout typemap for const std::string&
22605
22606   return jresult;
22607 }
22608
22609
22610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22611   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22612
22613   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22614   {
22615     try {
22616       delete arg1;
22617     } catch (std::out_of_range& e) {
22618       {
22619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22620       };
22621     } catch (std::exception& e) {
22622       {
22623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22624       };
22625     } catch (Dali::DaliException e) {
22626       {
22627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22628       };
22629     } catch (...) {
22630       {
22631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22632       };
22633     }
22634   }
22635
22636 }
22637
22638
22639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22640   void * jresult ;
22641   Dali::TypeRegistration *arg1 = 0 ;
22642   std::string *arg2 = 0 ;
22643   Dali::Property::Index arg3 ;
22644   Dali::Property::Index arg4 ;
22645   unsigned int arg5 ;
22646   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22647
22648   arg1 = (Dali::TypeRegistration *)jarg1;
22649   if (!arg1) {
22650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22651     return 0;
22652   }
22653   if (!jarg2) {
22654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22655     return 0;
22656   }
22657   std::string arg2_str(jarg2);
22658   arg2 = &arg2_str;
22659   arg3 = (Dali::Property::Index)jarg3;
22660   arg4 = (Dali::Property::Index)jarg4;
22661   arg5 = (unsigned int)jarg5;
22662   {
22663     try {
22664       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22665     } catch (std::out_of_range& e) {
22666       {
22667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22668       };
22669     } catch (std::exception& e) {
22670       {
22671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22672       };
22673     } catch (Dali::DaliException e) {
22674       {
22675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22676       };
22677     } catch (...) {
22678       {
22679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22680       };
22681     }
22682   }
22683
22684   jresult = (void *)result;
22685
22686   //argout typemap for const std::string&
22687
22688   return jresult;
22689 }
22690
22691
22692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22693   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22694
22695   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22696   {
22697     try {
22698       delete arg1;
22699     } catch (std::out_of_range& e) {
22700       {
22701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22702       };
22703     } catch (std::exception& e) {
22704       {
22705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22706       };
22707     } catch (Dali::DaliException e) {
22708       {
22709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22710       };
22711     } catch (...) {
22712       {
22713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22714       };
22715     }
22716   }
22717
22718 }
22719
22720
22721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22722   void * jresult ;
22723   Dali::TypeRegistration *arg1 = 0 ;
22724   std::string *arg2 = 0 ;
22725   Dali::Property::Index arg3 ;
22726   Dali::Property::Type arg4 ;
22727   Dali::ChildPropertyRegistration *result = 0 ;
22728
22729   arg1 = (Dali::TypeRegistration *)jarg1;
22730   if (!arg1) {
22731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22732     return 0;
22733   }
22734   if (!jarg2) {
22735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22736     return 0;
22737   }
22738   std::string arg2_str(jarg2);
22739   arg2 = &arg2_str;
22740   arg3 = (Dali::Property::Index)jarg3;
22741   arg4 = (Dali::Property::Type)jarg4;
22742   {
22743     try {
22744       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22745     } catch (std::out_of_range& e) {
22746       {
22747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22748       };
22749     } catch (std::exception& e) {
22750       {
22751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22752       };
22753     } catch (Dali::DaliException e) {
22754       {
22755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22756       };
22757     } catch (...) {
22758       {
22759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22760       };
22761     }
22762   }
22763
22764   jresult = (void *)result;
22765
22766   //argout typemap for const std::string&
22767
22768   return jresult;
22769 }
22770
22771
22772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22773   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22774
22775   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22776   {
22777     try {
22778       delete arg1;
22779     } catch (std::out_of_range& e) {
22780       {
22781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22782       };
22783     } catch (std::exception& e) {
22784       {
22785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22786       };
22787     } catch (Dali::DaliException e) {
22788       {
22789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22790       };
22791     } catch (...) {
22792       {
22793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22794       };
22795     }
22796   }
22797
22798 }
22799
22800
22801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22802   unsigned int jresult ;
22803   std::string *arg1 = 0 ;
22804   std::type_info *arg2 = 0 ;
22805   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22806   bool result;
22807
22808   if (!jarg1) {
22809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22810     return 0;
22811   }
22812   std::string arg1_str(jarg1);
22813   arg1 = &arg1_str;
22814   arg2 = (std::type_info *)jarg2;
22815   if (!arg2) {
22816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22817     return 0;
22818   }
22819   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22820   {
22821     try {
22822       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22823     } catch (std::out_of_range& e) {
22824       {
22825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22826       };
22827     } catch (std::exception& e) {
22828       {
22829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22830       };
22831     } catch (Dali::DaliException e) {
22832       {
22833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22834       };
22835     } catch (...) {
22836       {
22837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22838       };
22839     }
22840   }
22841
22842   jresult = result;
22843
22844   //argout typemap for const std::string&
22845
22846   return jresult;
22847 }
22848
22849
22850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22851   unsigned int jresult ;
22852   std::string *arg1 = 0 ;
22853   std::string *arg2 = 0 ;
22854   Dali::Property::Index arg3 ;
22855   Dali::Property::Type arg4 ;
22856   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22857   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22858   bool result;
22859
22860   if (!jarg1) {
22861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22862     return 0;
22863   }
22864   std::string arg1_str(jarg1);
22865   arg1 = &arg1_str;
22866   if (!jarg2) {
22867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22868     return 0;
22869   }
22870   std::string arg2_str(jarg2);
22871   arg2 = &arg2_str;
22872   arg3 = (Dali::Property::Index)jarg3;
22873   arg4 = (Dali::Property::Type)jarg4;
22874   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22875   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22876   {
22877     try {
22878       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22879     } catch (std::out_of_range& e) {
22880       {
22881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22882       };
22883     } catch (std::exception& e) {
22884       {
22885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22886       };
22887     } catch (Dali::DaliException e) {
22888       {
22889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22890       };
22891     } catch (...) {
22892       {
22893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22894       };
22895     }
22896   }
22897
22898   jresult = result;
22899
22900   //argout typemap for const std::string&
22901
22902
22903   //argout typemap for const std::string&
22904
22905   return jresult;
22906 }
22907
22908
22909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22910   float jresult ;
22911   float result;
22912
22913   result = (float)(float)Dali::ParentOrigin::TOP;
22914   jresult = result;
22915   return jresult;
22916 }
22917
22918
22919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22920   float jresult ;
22921   float result;
22922
22923   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22924   jresult = result;
22925   return jresult;
22926 }
22927
22928
22929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22930   float jresult ;
22931   float result;
22932
22933   result = (float)(float)Dali::ParentOrigin::LEFT;
22934   jresult = result;
22935   return jresult;
22936 }
22937
22938
22939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22940   float jresult ;
22941   float result;
22942
22943   result = (float)(float)Dali::ParentOrigin::RIGHT;
22944   jresult = result;
22945   return jresult;
22946 }
22947
22948
22949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22950   float jresult ;
22951   float result;
22952
22953   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22954   jresult = result;
22955   return jresult;
22956 }
22957
22958
22959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22960   void * jresult ;
22961   Dali::Vector3 *result = 0 ;
22962
22963   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22964   jresult = (void *)result;
22965   return jresult;
22966 }
22967
22968
22969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22970   void * jresult ;
22971   Dali::Vector3 *result = 0 ;
22972
22973   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22974   jresult = (void *)result;
22975   return jresult;
22976 }
22977
22978
22979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22980   void * jresult ;
22981   Dali::Vector3 *result = 0 ;
22982
22983   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22984   jresult = (void *)result;
22985   return jresult;
22986 }
22987
22988
22989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22990   void * jresult ;
22991   Dali::Vector3 *result = 0 ;
22992
22993   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22994   jresult = (void *)result;
22995   return jresult;
22996 }
22997
22998
22999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23000   void * jresult ;
23001   Dali::Vector3 *result = 0 ;
23002
23003   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23004   jresult = (void *)result;
23005   return jresult;
23006 }
23007
23008
23009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23010   void * jresult ;
23011   Dali::Vector3 *result = 0 ;
23012
23013   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23014   jresult = (void *)result;
23015   return jresult;
23016 }
23017
23018
23019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23020   void * jresult ;
23021   Dali::Vector3 *result = 0 ;
23022
23023   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23024   jresult = (void *)result;
23025   return jresult;
23026 }
23027
23028
23029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23030   void * jresult ;
23031   Dali::Vector3 *result = 0 ;
23032
23033   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23034   jresult = (void *)result;
23035   return jresult;
23036 }
23037
23038
23039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23040   void * jresult ;
23041   Dali::Vector3 *result = 0 ;
23042
23043   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23044   jresult = (void *)result;
23045   return jresult;
23046 }
23047
23048
23049 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23050   float jresult ;
23051   float result;
23052
23053   result = (float)(float)Dali::AnchorPoint::TOP;
23054   jresult = result;
23055   return jresult;
23056 }
23057
23058
23059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23060   float jresult ;
23061   float result;
23062
23063   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23064   jresult = result;
23065   return jresult;
23066 }
23067
23068
23069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23070   float jresult ;
23071   float result;
23072
23073   result = (float)(float)Dali::AnchorPoint::LEFT;
23074   jresult = result;
23075   return jresult;
23076 }
23077
23078
23079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23080   float jresult ;
23081   float result;
23082
23083   result = (float)(float)Dali::AnchorPoint::RIGHT;
23084   jresult = result;
23085   return jresult;
23086 }
23087
23088
23089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23090   float jresult ;
23091   float result;
23092
23093   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23094   jresult = result;
23095   return jresult;
23096 }
23097
23098
23099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23100   void * jresult ;
23101   Dali::Vector3 *result = 0 ;
23102
23103   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23104   jresult = (void *)result;
23105   return jresult;
23106 }
23107
23108
23109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23110   void * jresult ;
23111   Dali::Vector3 *result = 0 ;
23112
23113   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23114   jresult = (void *)result;
23115   return jresult;
23116 }
23117
23118
23119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23120   void * jresult ;
23121   Dali::Vector3 *result = 0 ;
23122
23123   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23124   jresult = (void *)result;
23125   return jresult;
23126 }
23127
23128
23129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23130   void * jresult ;
23131   Dali::Vector3 *result = 0 ;
23132
23133   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23134   jresult = (void *)result;
23135   return jresult;
23136 }
23137
23138
23139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23140   void * jresult ;
23141   Dali::Vector3 *result = 0 ;
23142
23143   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23144   jresult = (void *)result;
23145   return jresult;
23146 }
23147
23148
23149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23150   void * jresult ;
23151   Dali::Vector3 *result = 0 ;
23152
23153   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23154   jresult = (void *)result;
23155   return jresult;
23156 }
23157
23158
23159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23160   void * jresult ;
23161   Dali::Vector3 *result = 0 ;
23162
23163   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23164   jresult = (void *)result;
23165   return jresult;
23166 }
23167
23168
23169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23170   void * jresult ;
23171   Dali::Vector3 *result = 0 ;
23172
23173   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23174   jresult = (void *)result;
23175   return jresult;
23176 }
23177
23178
23179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23180   void * jresult ;
23181   Dali::Vector3 *result = 0 ;
23182
23183   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23184   jresult = (void *)result;
23185   return jresult;
23186 }
23187
23188
23189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23190   void * jresult ;
23191   Dali::Vector4 *result = 0 ;
23192
23193   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23194   jresult = (void *)result;
23195   return jresult;
23196 }
23197
23198
23199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23200   void * jresult ;
23201   Dali::Vector4 *result = 0 ;
23202
23203   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23204   jresult = (void *)result;
23205   return jresult;
23206 }
23207
23208
23209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23210   void * jresult ;
23211   Dali::Vector4 *result = 0 ;
23212
23213   result = (Dali::Vector4 *)&Dali::Color::RED;
23214   jresult = (void *)result;
23215   return jresult;
23216 }
23217
23218
23219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23220   void * jresult ;
23221   Dali::Vector4 *result = 0 ;
23222
23223   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23224   jresult = (void *)result;
23225   return jresult;
23226 }
23227
23228
23229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23230   void * jresult ;
23231   Dali::Vector4 *result = 0 ;
23232
23233   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23234   jresult = (void *)result;
23235   return jresult;
23236 }
23237
23238
23239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23240   void * jresult ;
23241   Dali::Vector4 *result = 0 ;
23242
23243   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23244   jresult = (void *)result;
23245   return jresult;
23246 }
23247
23248
23249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23250   void * jresult ;
23251   Dali::Vector4 *result = 0 ;
23252
23253   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23254   jresult = (void *)result;
23255   return jresult;
23256 }
23257
23258
23259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23260   void * jresult ;
23261   Dali::Vector4 *result = 0 ;
23262
23263   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23264   jresult = (void *)result;
23265   return jresult;
23266 }
23267
23268
23269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23270   void * jresult ;
23271   Dali::Vector4 *result = 0 ;
23272
23273   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23274   jresult = (void *)result;
23275   return jresult;
23276 }
23277
23278
23279 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23280   float jresult ;
23281   float result;
23282
23283   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23284   jresult = result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23290   float jresult ;
23291   float result;
23292
23293   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23294   jresult = result;
23295   return jresult;
23296 }
23297
23298
23299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23300   float jresult ;
23301   float result;
23302
23303   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23304   jresult = result;
23305   return jresult;
23306 }
23307
23308
23309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23310   float jresult ;
23311   float result;
23312
23313   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23314   jresult = result;
23315   return jresult;
23316 }
23317
23318
23319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23320   float jresult ;
23321   float result;
23322
23323   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23324   jresult = result;
23325   return jresult;
23326 }
23327
23328
23329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23330   float jresult ;
23331   float result;
23332
23333   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23334   jresult = result;
23335   return jresult;
23336 }
23337
23338
23339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23340   float jresult ;
23341   float result;
23342
23343   result = (float)(float)Dali::Math::PI;
23344   jresult = result;
23345   return jresult;
23346 }
23347
23348
23349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23350   float jresult ;
23351   float result;
23352
23353   result = (float)(float)Dali::Math::PI_2;
23354   jresult = result;
23355   return jresult;
23356 }
23357
23358
23359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23360   float jresult ;
23361   float result;
23362
23363   result = (float)(float)Dali::Math::PI_4;
23364   jresult = result;
23365   return jresult;
23366 }
23367
23368
23369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23370   float jresult ;
23371   float result;
23372
23373   result = (float)(float)Dali::Math::PI_OVER_180;
23374   jresult = result;
23375   return jresult;
23376 }
23377
23378
23379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23380   float jresult ;
23381   float result;
23382
23383   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23384   jresult = result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23390   int jresult ;
23391   Dali::ResizePolicy::Type result;
23392
23393   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23394   jresult = (int)result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23400   unsigned long jresult ;
23401   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23402   Dali::VectorBase::SizeType result;
23403
23404   arg1 = (Dali::VectorBase *)jarg1;
23405   {
23406     try {
23407       result = ((Dali::VectorBase const *)arg1)->Count();
23408     } catch (std::out_of_range& e) {
23409       {
23410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23411       };
23412     } catch (std::exception& e) {
23413       {
23414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23415       };
23416     } catch (Dali::DaliException e) {
23417       {
23418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23419       };
23420     } catch (...) {
23421       {
23422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23423       };
23424     }
23425   }
23426
23427   jresult = (unsigned long)result;
23428   return jresult;
23429 }
23430
23431
23432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23433   unsigned long jresult ;
23434   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23435   Dali::VectorBase::SizeType result;
23436
23437   arg1 = (Dali::VectorBase *)jarg1;
23438   {
23439     try {
23440       result = ((Dali::VectorBase const *)arg1)->Size();
23441     } catch (std::out_of_range& e) {
23442       {
23443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23444       };
23445     } catch (std::exception& e) {
23446       {
23447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23448       };
23449     } catch (Dali::DaliException e) {
23450       {
23451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23452       };
23453     } catch (...) {
23454       {
23455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23456       };
23457     }
23458   }
23459
23460   jresult = (unsigned long)result;
23461   return jresult;
23462 }
23463
23464
23465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23466   unsigned int jresult ;
23467   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23468   bool result;
23469
23470   arg1 = (Dali::VectorBase *)jarg1;
23471   {
23472     try {
23473       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23474     } catch (std::out_of_range& e) {
23475       {
23476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23477       };
23478     } catch (std::exception& e) {
23479       {
23480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23481       };
23482     } catch (Dali::DaliException e) {
23483       {
23484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23485       };
23486     } catch (...) {
23487       {
23488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23489       };
23490     }
23491   }
23492
23493   jresult = result;
23494   return jresult;
23495 }
23496
23497
23498 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23499   unsigned long jresult ;
23500   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23501   Dali::VectorBase::SizeType result;
23502
23503   arg1 = (Dali::VectorBase *)jarg1;
23504   {
23505     try {
23506       result = ((Dali::VectorBase const *)arg1)->Capacity();
23507     } catch (std::out_of_range& e) {
23508       {
23509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23510       };
23511     } catch (std::exception& e) {
23512       {
23513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23514       };
23515     } catch (Dali::DaliException e) {
23516       {
23517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23518       };
23519     } catch (...) {
23520       {
23521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23522       };
23523     }
23524   }
23525
23526   jresult = (unsigned long)result;
23527   return jresult;
23528 }
23529
23530
23531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23532   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23533
23534   arg1 = (Dali::VectorBase *)jarg1;
23535   {
23536     try {
23537       (arg1)->Release();
23538     } catch (std::out_of_range& e) {
23539       {
23540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23541       };
23542     } catch (std::exception& e) {
23543       {
23544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23545       };
23546     } catch (Dali::DaliException e) {
23547       {
23548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23549       };
23550     } catch (...) {
23551       {
23552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23553       };
23554     }
23555   }
23556
23557 }
23558
23559
23560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23561   void * jresult ;
23562   Dali::Image *result = 0 ;
23563
23564   {
23565     try {
23566       result = (Dali::Image *)new Dali::Image();
23567     } catch (std::out_of_range& e) {
23568       {
23569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23570       };
23571     } catch (std::exception& e) {
23572       {
23573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23574       };
23575     } catch (Dali::DaliException e) {
23576       {
23577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23578       };
23579     } catch (...) {
23580       {
23581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23582       };
23583     }
23584   }
23585
23586   jresult = (void *)result;
23587   return jresult;
23588 }
23589
23590
23591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23592   Dali::Image *arg1 = (Dali::Image *) 0 ;
23593
23594   arg1 = (Dali::Image *)jarg1;
23595   {
23596     try {
23597       delete arg1;
23598     } catch (std::out_of_range& e) {
23599       {
23600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23601       };
23602     } catch (std::exception& e) {
23603       {
23604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23605       };
23606     } catch (Dali::DaliException e) {
23607       {
23608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23609       };
23610     } catch (...) {
23611       {
23612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23613       };
23614     }
23615   }
23616
23617 }
23618
23619
23620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23621   void * jresult ;
23622   Dali::Image *arg1 = 0 ;
23623   Dali::Image *result = 0 ;
23624
23625   arg1 = (Dali::Image *)jarg1;
23626   if (!arg1) {
23627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23628     return 0;
23629   }
23630   {
23631     try {
23632       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23633     } catch (std::out_of_range& e) {
23634       {
23635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23636       };
23637     } catch (std::exception& e) {
23638       {
23639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23640       };
23641     } catch (Dali::DaliException e) {
23642       {
23643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23644       };
23645     } catch (...) {
23646       {
23647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23648       };
23649     }
23650   }
23651
23652   jresult = (void *)result;
23653   return jresult;
23654 }
23655
23656
23657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23658   void * jresult ;
23659   Dali::Image *arg1 = (Dali::Image *) 0 ;
23660   Dali::Image *arg2 = 0 ;
23661   Dali::Image *result = 0 ;
23662
23663   arg1 = (Dali::Image *)jarg1;
23664   arg2 = (Dali::Image *)jarg2;
23665   if (!arg2) {
23666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23667     return 0;
23668   }
23669   {
23670     try {
23671       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23672     } catch (std::out_of_range& e) {
23673       {
23674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23675       };
23676     } catch (std::exception& e) {
23677       {
23678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23679       };
23680     } catch (Dali::DaliException e) {
23681       {
23682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23683       };
23684     } catch (...) {
23685       {
23686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23687       };
23688     }
23689   }
23690
23691   jresult = (void *)result;
23692   return jresult;
23693 }
23694
23695
23696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23697   void * jresult ;
23698   Dali::BaseHandle arg1 ;
23699   Dali::BaseHandle *argp1 ;
23700   Dali::Image result;
23701
23702   argp1 = (Dali::BaseHandle *)jarg1;
23703   if (!argp1) {
23704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23705     return 0;
23706   }
23707   arg1 = *argp1;
23708   {
23709     try {
23710       result = Dali::Image::DownCast(arg1);
23711     } catch (std::out_of_range& e) {
23712       {
23713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23714       };
23715     } catch (std::exception& e) {
23716       {
23717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23718       };
23719     } catch (Dali::DaliException e) {
23720       {
23721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23722       };
23723     } catch (...) {
23724       {
23725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23726       };
23727     }
23728   }
23729
23730   jresult = new Dali::Image((const Dali::Image &)result);
23731   return jresult;
23732 }
23733
23734
23735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23736   unsigned int jresult ;
23737   Dali::Image *arg1 = (Dali::Image *) 0 ;
23738   unsigned int result;
23739
23740   arg1 = (Dali::Image *)jarg1;
23741   {
23742     try {
23743       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23744     } catch (std::out_of_range& e) {
23745       {
23746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23747       };
23748     } catch (std::exception& e) {
23749       {
23750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23751       };
23752     } catch (Dali::DaliException e) {
23753       {
23754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23755       };
23756     } catch (...) {
23757       {
23758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23759       };
23760     }
23761   }
23762
23763   jresult = result;
23764   return jresult;
23765 }
23766
23767
23768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23769   unsigned int jresult ;
23770   Dali::Image *arg1 = (Dali::Image *) 0 ;
23771   unsigned int result;
23772
23773   arg1 = (Dali::Image *)jarg1;
23774   {
23775     try {
23776       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23777     } catch (std::out_of_range& e) {
23778       {
23779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23780       };
23781     } catch (std::exception& e) {
23782       {
23783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23784       };
23785     } catch (Dali::DaliException e) {
23786       {
23787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23788       };
23789     } catch (...) {
23790       {
23791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23792       };
23793     }
23794   }
23795
23796   jresult = result;
23797   return jresult;
23798 }
23799
23800
23801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23802   void * jresult ;
23803   Dali::Image *arg1 = (Dali::Image *) 0 ;
23804   Dali::Image::ImageSignalType *result = 0 ;
23805
23806   arg1 = (Dali::Image *)jarg1;
23807   {
23808     try {
23809       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23810     } catch (std::out_of_range& e) {
23811       {
23812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23813       };
23814     } catch (std::exception& e) {
23815       {
23816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23817       };
23818     } catch (Dali::DaliException e) {
23819       {
23820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23821       };
23822     } catch (...) {
23823       {
23824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23825       };
23826     }
23827   }
23828
23829   jresult = (void *)result;
23830   return jresult;
23831 }
23832
23833
23834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23835   int jresult ;
23836   Dali::Pixel::Format result;
23837
23838   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23839   jresult = (int)result;
23840   return jresult;
23841 }
23842
23843
23844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23845   int jresult ;
23846   Dali::Pixel::Format result;
23847
23848   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23849   jresult = (int)result;
23850   return jresult;
23851 }
23852
23853
23854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23855   unsigned int jresult ;
23856   Dali::Pixel::Format arg1 ;
23857   bool result;
23858
23859   arg1 = (Dali::Pixel::Format)jarg1;
23860   {
23861     try {
23862       result = (bool)Dali::Pixel::HasAlpha(arg1);
23863     } catch (std::out_of_range& e) {
23864       {
23865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23866       };
23867     } catch (std::exception& e) {
23868       {
23869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23870       };
23871     } catch (Dali::DaliException e) {
23872       {
23873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23874       };
23875     } catch (...) {
23876       {
23877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23878       };
23879     }
23880   }
23881
23882   jresult = result;
23883   return jresult;
23884 }
23885
23886
23887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23888   unsigned int jresult ;
23889   Dali::Pixel::Format arg1 ;
23890   unsigned int result;
23891
23892   arg1 = (Dali::Pixel::Format)jarg1;
23893   {
23894     try {
23895       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23896     } catch (std::out_of_range& e) {
23897       {
23898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23899       };
23900     } catch (std::exception& e) {
23901       {
23902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23903       };
23904     } catch (Dali::DaliException e) {
23905       {
23906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23907       };
23908     } catch (...) {
23909       {
23910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23911       };
23912     }
23913   }
23914
23915   jresult = result;
23916   return jresult;
23917 }
23918
23919
23920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23921   Dali::Pixel::Format arg1 ;
23922   int *arg2 = 0 ;
23923   int *arg3 = 0 ;
23924
23925   arg1 = (Dali::Pixel::Format)jarg1;
23926   arg2 = (int *)jarg2;
23927   if (!arg2) {
23928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23929     return ;
23930   }
23931   arg3 = (int *)jarg3;
23932   if (!arg3) {
23933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23934     return ;
23935   }
23936   {
23937     try {
23938       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23939     } catch (std::out_of_range& e) {
23940       {
23941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23942       };
23943     } catch (std::exception& e) {
23944       {
23945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23946       };
23947     } catch (Dali::DaliException e) {
23948       {
23949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23950       };
23951     } catch (...) {
23952       {
23953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23954       };
23955     }
23956   }
23957
23958 }
23959
23960
23961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23962   void * jresult ;
23963   unsigned char *arg1 = (unsigned char *) 0 ;
23964   unsigned int arg2 ;
23965   unsigned int arg3 ;
23966   unsigned int arg4 ;
23967   Dali::Pixel::Format arg5 ;
23968   Dali::PixelData::ReleaseFunction arg6 ;
23969   Dali::PixelData result;
23970
23971   arg1 = jarg1;
23972   arg2 = (unsigned int)jarg2;
23973   arg3 = (unsigned int)jarg3;
23974   arg4 = (unsigned int)jarg4;
23975   arg5 = (Dali::Pixel::Format)jarg5;
23976   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23977   {
23978     try {
23979       auto pixelBuffer = new unsigned char[jarg2];
23980       memcpy( pixelBuffer, arg1, arg2);
23981       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23982     } catch (std::out_of_range& e) {
23983       {
23984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23985       };
23986     } catch (std::exception& e) {
23987       {
23988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23989       };
23990     } catch (Dali::DaliException e) {
23991       {
23992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23993       };
23994     } catch (...) {
23995       {
23996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23997       };
23998     }
23999   }
24000
24001   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24002
24003
24004   return jresult;
24005 }
24006
24007
24008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24009   void * jresult ;
24010   Dali::PixelData *result = 0 ;
24011
24012   {
24013     try {
24014       result = (Dali::PixelData *)new Dali::PixelData();
24015     } catch (std::out_of_range& e) {
24016       {
24017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24018       };
24019     } catch (std::exception& e) {
24020       {
24021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24022       };
24023     } catch (Dali::DaliException e) {
24024       {
24025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24026       };
24027     } catch (...) {
24028       {
24029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24030       };
24031     }
24032   }
24033
24034   jresult = (void *)result;
24035   return jresult;
24036 }
24037
24038
24039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24040   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24041
24042   arg1 = (Dali::PixelData *)jarg1;
24043   {
24044     try {
24045       delete arg1;
24046     } catch (std::out_of_range& e) {
24047       {
24048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24049       };
24050     } catch (std::exception& e) {
24051       {
24052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24053       };
24054     } catch (Dali::DaliException e) {
24055       {
24056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24057       };
24058     } catch (...) {
24059       {
24060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24061       };
24062     }
24063   }
24064
24065 }
24066
24067
24068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24069   void * jresult ;
24070   Dali::PixelData *arg1 = 0 ;
24071   Dali::PixelData *result = 0 ;
24072
24073   arg1 = (Dali::PixelData *)jarg1;
24074   if (!arg1) {
24075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24076     return 0;
24077   }
24078   {
24079     try {
24080       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24081     } catch (std::out_of_range& e) {
24082       {
24083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24084       };
24085     } catch (std::exception& e) {
24086       {
24087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24088       };
24089     } catch (Dali::DaliException e) {
24090       {
24091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24092       };
24093     } catch (...) {
24094       {
24095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24096       };
24097     }
24098   }
24099
24100   jresult = (void *)result;
24101   return jresult;
24102 }
24103
24104
24105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24106   void * jresult ;
24107   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24108   Dali::PixelData *arg2 = 0 ;
24109   Dali::PixelData *result = 0 ;
24110
24111   arg1 = (Dali::PixelData *)jarg1;
24112   arg2 = (Dali::PixelData *)jarg2;
24113   if (!arg2) {
24114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24115     return 0;
24116   }
24117   {
24118     try {
24119       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24120     } catch (std::out_of_range& e) {
24121       {
24122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24123       };
24124     } catch (std::exception& e) {
24125       {
24126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24127       };
24128     } catch (Dali::DaliException e) {
24129       {
24130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24131       };
24132     } catch (...) {
24133       {
24134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24135       };
24136     }
24137   }
24138
24139   jresult = (void *)result;
24140   return jresult;
24141 }
24142
24143
24144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24145   unsigned int jresult ;
24146   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24147   unsigned int result;
24148
24149   arg1 = (Dali::PixelData *)jarg1;
24150   {
24151     try {
24152       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24153     } catch (std::out_of_range& e) {
24154       {
24155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24156       };
24157     } catch (std::exception& e) {
24158       {
24159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24160       };
24161     } catch (Dali::DaliException e) {
24162       {
24163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24164       };
24165     } catch (...) {
24166       {
24167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24168       };
24169     }
24170   }
24171
24172   jresult = result;
24173   return jresult;
24174 }
24175
24176
24177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24178   unsigned int jresult ;
24179   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24180   unsigned int result;
24181
24182   arg1 = (Dali::PixelData *)jarg1;
24183   {
24184     try {
24185       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24186     } catch (std::out_of_range& e) {
24187       {
24188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24189       };
24190     } catch (std::exception& e) {
24191       {
24192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24193       };
24194     } catch (Dali::DaliException e) {
24195       {
24196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24197       };
24198     } catch (...) {
24199       {
24200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24201       };
24202     }
24203   }
24204
24205   jresult = result;
24206   return jresult;
24207 }
24208
24209
24210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24211   int jresult ;
24212   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24213   Dali::Pixel::Format result;
24214
24215   arg1 = (Dali::PixelData *)jarg1;
24216   {
24217     try {
24218       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24219     } catch (std::out_of_range& e) {
24220       {
24221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24222       };
24223     } catch (std::exception& e) {
24224       {
24225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24226       };
24227     } catch (Dali::DaliException e) {
24228       {
24229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24230       };
24231     } catch (...) {
24232       {
24233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24234       };
24235     }
24236   }
24237
24238   jresult = (int)result;
24239   return jresult;
24240 }
24241
24242
24243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24244   unsigned int jresult ;
24245   unsigned int result;
24246
24247   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24248   jresult = result;
24249   return jresult;
24250 }
24251
24252
24253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24254   unsigned int jresult ;
24255   unsigned int result;
24256
24257   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24258   jresult = result;
24259   return jresult;
24260 }
24261
24262
24263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24264   unsigned int jresult ;
24265   unsigned int result;
24266
24267   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24268   jresult = result;
24269   return jresult;
24270 }
24271
24272
24273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24274   unsigned int jresult ;
24275   unsigned int result;
24276
24277   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24278   jresult = result;
24279   return jresult;
24280 }
24281
24282
24283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24284   unsigned int jresult ;
24285   unsigned int result;
24286
24287   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24288   jresult = result;
24289   return jresult;
24290 }
24291
24292
24293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24294   unsigned int jresult ;
24295   unsigned int result;
24296
24297   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24298   jresult = result;
24299   return jresult;
24300 }
24301
24302
24303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24304   void * jresult ;
24305   Dali::TextureType::Type arg1 ;
24306   Dali::Pixel::Format arg2 ;
24307   unsigned int arg3 ;
24308   unsigned int arg4 ;
24309   Dali::Texture result;
24310
24311   arg1 = (Dali::TextureType::Type)jarg1;
24312   arg2 = (Dali::Pixel::Format)jarg2;
24313   arg3 = (unsigned int)jarg3;
24314   arg4 = (unsigned int)jarg4;
24315   {
24316     try {
24317       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24318     } catch (std::out_of_range& e) {
24319       {
24320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24321       };
24322     } catch (std::exception& e) {
24323       {
24324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24325       };
24326     } catch (Dali::DaliException e) {
24327       {
24328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24329       };
24330     } catch (...) {
24331       {
24332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24333       };
24334     }
24335   }
24336
24337   jresult = new Dali::Texture((const Dali::Texture &)result);
24338   return jresult;
24339 }
24340
24341
24342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24343   void * jresult ;
24344   NativeImageInterface *arg1 = 0 ;
24345   Dali::Texture result;
24346
24347   arg1 = (NativeImageInterface *)jarg1;
24348   if (!arg1) {
24349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24350     return 0;
24351   }
24352   {
24353     try {
24354       result = Dali::Texture::New(*arg1);
24355     } catch (std::out_of_range& e) {
24356       {
24357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24358       };
24359     } catch (std::exception& e) {
24360       {
24361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24362       };
24363     } catch (Dali::DaliException e) {
24364       {
24365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24366       };
24367     } catch (...) {
24368       {
24369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24370       };
24371     }
24372   }
24373
24374   jresult = new Dali::Texture((const Dali::Texture &)result);
24375   return jresult;
24376 }
24377
24378
24379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24380   void * jresult ;
24381   Dali::Texture *result = 0 ;
24382
24383   {
24384     try {
24385       result = (Dali::Texture *)new Dali::Texture();
24386     } catch (std::out_of_range& e) {
24387       {
24388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24389       };
24390     } catch (std::exception& e) {
24391       {
24392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24393       };
24394     } catch (Dali::DaliException e) {
24395       {
24396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24397       };
24398     } catch (...) {
24399       {
24400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24401       };
24402     }
24403   }
24404
24405   jresult = (void *)result;
24406   return jresult;
24407 }
24408
24409
24410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24411   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24412
24413   arg1 = (Dali::Texture *)jarg1;
24414   {
24415     try {
24416       delete arg1;
24417     } catch (std::out_of_range& e) {
24418       {
24419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24420       };
24421     } catch (std::exception& e) {
24422       {
24423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24424       };
24425     } catch (Dali::DaliException e) {
24426       {
24427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24428       };
24429     } catch (...) {
24430       {
24431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24432       };
24433     }
24434   }
24435
24436 }
24437
24438
24439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24440   void * jresult ;
24441   Dali::Texture *arg1 = 0 ;
24442   Dali::Texture *result = 0 ;
24443
24444   arg1 = (Dali::Texture *)jarg1;
24445   if (!arg1) {
24446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24447     return 0;
24448   }
24449   {
24450     try {
24451       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24452     } catch (std::out_of_range& e) {
24453       {
24454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24455       };
24456     } catch (std::exception& e) {
24457       {
24458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24459       };
24460     } catch (Dali::DaliException e) {
24461       {
24462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24463       };
24464     } catch (...) {
24465       {
24466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24467       };
24468     }
24469   }
24470
24471   jresult = (void *)result;
24472   return jresult;
24473 }
24474
24475
24476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24477   void * jresult ;
24478   Dali::BaseHandle arg1 ;
24479   Dali::BaseHandle *argp1 ;
24480   Dali::Texture result;
24481
24482   argp1 = (Dali::BaseHandle *)jarg1;
24483   if (!argp1) {
24484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24485     return 0;
24486   }
24487   arg1 = *argp1;
24488   {
24489     try {
24490       result = Dali::Texture::DownCast(arg1);
24491     } catch (std::out_of_range& e) {
24492       {
24493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24494       };
24495     } catch (std::exception& e) {
24496       {
24497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24498       };
24499     } catch (Dali::DaliException e) {
24500       {
24501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24502       };
24503     } catch (...) {
24504       {
24505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24506       };
24507     }
24508   }
24509
24510   jresult = new Dali::Texture((const Dali::Texture &)result);
24511   return jresult;
24512 }
24513
24514
24515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24516   void * jresult ;
24517   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24518   Dali::Texture *arg2 = 0 ;
24519   Dali::Texture *result = 0 ;
24520
24521   arg1 = (Dali::Texture *)jarg1;
24522   arg2 = (Dali::Texture *)jarg2;
24523   if (!arg2) {
24524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24525     return 0;
24526   }
24527   {
24528     try {
24529       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24530     } catch (std::out_of_range& e) {
24531       {
24532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24533       };
24534     } catch (std::exception& e) {
24535       {
24536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24537       };
24538     } catch (Dali::DaliException e) {
24539       {
24540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24541       };
24542     } catch (...) {
24543       {
24544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24545       };
24546     }
24547   }
24548
24549   jresult = (void *)result;
24550   return jresult;
24551 }
24552
24553
24554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24555   unsigned int jresult ;
24556   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24557   Dali::PixelData arg2 ;
24558   Dali::PixelData *argp2 ;
24559   bool result;
24560
24561   arg1 = (Dali::Texture *)jarg1;
24562   argp2 = (Dali::PixelData *)jarg2;
24563   if (!argp2) {
24564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24565     return 0;
24566   }
24567   arg2 = *argp2;
24568   {
24569     try {
24570       result = (bool)(arg1)->Upload(arg2);
24571     } catch (std::out_of_range& e) {
24572       {
24573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24574       };
24575     } catch (std::exception& e) {
24576       {
24577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24578       };
24579     } catch (Dali::DaliException e) {
24580       {
24581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24582       };
24583     } catch (...) {
24584       {
24585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24586       };
24587     }
24588   }
24589
24590   jresult = result;
24591   return jresult;
24592 }
24593
24594
24595 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) {
24596   unsigned int jresult ;
24597   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24598   Dali::PixelData arg2 ;
24599   unsigned int arg3 ;
24600   unsigned int arg4 ;
24601   unsigned int arg5 ;
24602   unsigned int arg6 ;
24603   unsigned int arg7 ;
24604   unsigned int arg8 ;
24605   Dali::PixelData *argp2 ;
24606   bool result;
24607
24608   arg1 = (Dali::Texture *)jarg1;
24609   argp2 = (Dali::PixelData *)jarg2;
24610   if (!argp2) {
24611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24612     return 0;
24613   }
24614   arg2 = *argp2;
24615   arg3 = (unsigned int)jarg3;
24616   arg4 = (unsigned int)jarg4;
24617   arg5 = (unsigned int)jarg5;
24618   arg6 = (unsigned int)jarg6;
24619   arg7 = (unsigned int)jarg7;
24620   arg8 = (unsigned int)jarg8;
24621   {
24622     try {
24623       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24624     } catch (std::out_of_range& e) {
24625       {
24626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24627       };
24628     } catch (std::exception& e) {
24629       {
24630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24631       };
24632     } catch (Dali::DaliException e) {
24633       {
24634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24635       };
24636     } catch (...) {
24637       {
24638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24639       };
24640     }
24641   }
24642
24643   jresult = result;
24644   return jresult;
24645 }
24646
24647
24648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24649   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24650
24651   arg1 = (Dali::Texture *)jarg1;
24652   {
24653     try {
24654       (arg1)->GenerateMipmaps();
24655     } catch (std::out_of_range& e) {
24656       {
24657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24658       };
24659     } catch (std::exception& e) {
24660       {
24661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24662       };
24663     } catch (Dali::DaliException e) {
24664       {
24665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24666       };
24667     } catch (...) {
24668       {
24669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24670       };
24671     }
24672   }
24673
24674 }
24675
24676
24677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24678   unsigned int jresult ;
24679   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24680   unsigned int result;
24681
24682   arg1 = (Dali::Texture *)jarg1;
24683   {
24684     try {
24685       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24686     } catch (std::out_of_range& e) {
24687       {
24688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24689       };
24690     } catch (std::exception& e) {
24691       {
24692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24693       };
24694     } catch (Dali::DaliException e) {
24695       {
24696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24697       };
24698     } catch (...) {
24699       {
24700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24701       };
24702     }
24703   }
24704
24705   jresult = result;
24706   return jresult;
24707 }
24708
24709
24710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24711   unsigned int jresult ;
24712   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24713   unsigned int result;
24714
24715   arg1 = (Dali::Texture *)jarg1;
24716   {
24717     try {
24718       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24719     } catch (std::out_of_range& e) {
24720       {
24721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24722       };
24723     } catch (std::exception& e) {
24724       {
24725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24726       };
24727     } catch (Dali::DaliException e) {
24728       {
24729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24730       };
24731     } catch (...) {
24732       {
24733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24734       };
24735     }
24736   }
24737
24738   jresult = result;
24739   return jresult;
24740 }
24741
24742
24743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24744   void * jresult ;
24745   Dali::Sampler result;
24746
24747   {
24748     try {
24749       result = Dali::Sampler::New();
24750     } catch (std::out_of_range& e) {
24751       {
24752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24753       };
24754     } catch (std::exception& e) {
24755       {
24756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24757       };
24758     } catch (Dali::DaliException e) {
24759       {
24760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24761       };
24762     } catch (...) {
24763       {
24764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24765       };
24766     }
24767   }
24768
24769   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24770   return jresult;
24771 }
24772
24773
24774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24775   void * jresult ;
24776   Dali::Sampler *result = 0 ;
24777
24778   {
24779     try {
24780       result = (Dali::Sampler *)new Dali::Sampler();
24781     } catch (std::out_of_range& e) {
24782       {
24783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24784       };
24785     } catch (std::exception& e) {
24786       {
24787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24788       };
24789     } catch (Dali::DaliException e) {
24790       {
24791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24792       };
24793     } catch (...) {
24794       {
24795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24796       };
24797     }
24798   }
24799
24800   jresult = (void *)result;
24801   return jresult;
24802 }
24803
24804
24805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24806   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24807
24808   arg1 = (Dali::Sampler *)jarg1;
24809   {
24810     try {
24811       delete arg1;
24812     } catch (std::out_of_range& e) {
24813       {
24814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24815       };
24816     } catch (std::exception& e) {
24817       {
24818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24819       };
24820     } catch (Dali::DaliException e) {
24821       {
24822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24823       };
24824     } catch (...) {
24825       {
24826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24827       };
24828     }
24829   }
24830
24831 }
24832
24833
24834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24835   void * jresult ;
24836   Dali::Sampler *arg1 = 0 ;
24837   Dali::Sampler *result = 0 ;
24838
24839   arg1 = (Dali::Sampler *)jarg1;
24840   if (!arg1) {
24841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24842     return 0;
24843   }
24844   {
24845     try {
24846       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24847     } catch (std::out_of_range& e) {
24848       {
24849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24850       };
24851     } catch (std::exception& e) {
24852       {
24853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24854       };
24855     } catch (Dali::DaliException e) {
24856       {
24857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24858       };
24859     } catch (...) {
24860       {
24861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24862       };
24863     }
24864   }
24865
24866   jresult = (void *)result;
24867   return jresult;
24868 }
24869
24870
24871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24872   void * jresult ;
24873   Dali::BaseHandle arg1 ;
24874   Dali::BaseHandle *argp1 ;
24875   Dali::Sampler result;
24876
24877   argp1 = (Dali::BaseHandle *)jarg1;
24878   if (!argp1) {
24879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24880     return 0;
24881   }
24882   arg1 = *argp1;
24883   {
24884     try {
24885       result = Dali::Sampler::DownCast(arg1);
24886     } catch (std::out_of_range& e) {
24887       {
24888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24889       };
24890     } catch (std::exception& e) {
24891       {
24892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24893       };
24894     } catch (Dali::DaliException e) {
24895       {
24896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24897       };
24898     } catch (...) {
24899       {
24900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24901       };
24902     }
24903   }
24904
24905   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24906   return jresult;
24907 }
24908
24909
24910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24911   void * jresult ;
24912   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24913   Dali::Sampler *arg2 = 0 ;
24914   Dali::Sampler *result = 0 ;
24915
24916   arg1 = (Dali::Sampler *)jarg1;
24917   arg2 = (Dali::Sampler *)jarg2;
24918   if (!arg2) {
24919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24920     return 0;
24921   }
24922   {
24923     try {
24924       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24925     } catch (std::out_of_range& e) {
24926       {
24927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24928       };
24929     } catch (std::exception& e) {
24930       {
24931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24932       };
24933     } catch (Dali::DaliException e) {
24934       {
24935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24936       };
24937     } catch (...) {
24938       {
24939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24940       };
24941     }
24942   }
24943
24944   jresult = (void *)result;
24945   return jresult;
24946 }
24947
24948
24949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24950   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24951   Dali::FilterMode::Type arg2 ;
24952   Dali::FilterMode::Type arg3 ;
24953
24954   arg1 = (Dali::Sampler *)jarg1;
24955   arg2 = (Dali::FilterMode::Type)jarg2;
24956   arg3 = (Dali::FilterMode::Type)jarg3;
24957   {
24958     try {
24959       (arg1)->SetFilterMode(arg2,arg3);
24960     } catch (std::out_of_range& e) {
24961       {
24962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24963       };
24964     } catch (std::exception& e) {
24965       {
24966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24967       };
24968     } catch (Dali::DaliException e) {
24969       {
24970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24971       };
24972     } catch (...) {
24973       {
24974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24975       };
24976     }
24977   }
24978
24979 }
24980
24981
24982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24983   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24984   Dali::WrapMode::Type arg2 ;
24985   Dali::WrapMode::Type arg3 ;
24986
24987   arg1 = (Dali::Sampler *)jarg1;
24988   arg2 = (Dali::WrapMode::Type)jarg2;
24989   arg3 = (Dali::WrapMode::Type)jarg3;
24990   {
24991     try {
24992       (arg1)->SetWrapMode(arg2,arg3);
24993     } catch (std::out_of_range& e) {
24994       {
24995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24996       };
24997     } catch (std::exception& e) {
24998       {
24999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25000       };
25001     } catch (Dali::DaliException e) {
25002       {
25003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25004       };
25005     } catch (...) {
25006       {
25007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25008       };
25009     }
25010   }
25011
25012 }
25013
25014
25015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25016   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25017   Dali::WrapMode::Type arg2 ;
25018   Dali::WrapMode::Type arg3 ;
25019   Dali::WrapMode::Type arg4 ;
25020
25021   arg1 = (Dali::Sampler *)jarg1;
25022   arg2 = (Dali::WrapMode::Type)jarg2;
25023   arg3 = (Dali::WrapMode::Type)jarg3;
25024   arg4 = (Dali::WrapMode::Type)jarg4;
25025   {
25026     try {
25027       (arg1)->SetWrapMode(arg2,arg3,arg4);
25028     } catch (std::out_of_range& e) {
25029       {
25030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25031       };
25032     } catch (std::exception& e) {
25033       {
25034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25035       };
25036     } catch (Dali::DaliException e) {
25037       {
25038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25039       };
25040     } catch (...) {
25041       {
25042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25043       };
25044     }
25045   }
25046
25047 }
25048
25049
25050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25051   void * jresult ;
25052   Dali::TextureSet result;
25053
25054   {
25055     try {
25056       result = Dali::TextureSet::New();
25057     } catch (std::out_of_range& e) {
25058       {
25059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25060       };
25061     } catch (std::exception& e) {
25062       {
25063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25064       };
25065     } catch (Dali::DaliException e) {
25066       {
25067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25068       };
25069     } catch (...) {
25070       {
25071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25072       };
25073     }
25074   }
25075
25076   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25077   return jresult;
25078 }
25079
25080
25081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25082   void * jresult ;
25083   Dali::TextureSet *result = 0 ;
25084
25085   {
25086     try {
25087       result = (Dali::TextureSet *)new Dali::TextureSet();
25088     } catch (std::out_of_range& e) {
25089       {
25090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25091       };
25092     } catch (std::exception& e) {
25093       {
25094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25095       };
25096     } catch (Dali::DaliException e) {
25097       {
25098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25099       };
25100     } catch (...) {
25101       {
25102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25103       };
25104     }
25105   }
25106
25107   jresult = (void *)result;
25108   return jresult;
25109 }
25110
25111
25112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25113   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25114
25115   arg1 = (Dali::TextureSet *)jarg1;
25116   {
25117     try {
25118       delete arg1;
25119     } catch (std::out_of_range& e) {
25120       {
25121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25122       };
25123     } catch (std::exception& e) {
25124       {
25125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25126       };
25127     } catch (Dali::DaliException e) {
25128       {
25129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25130       };
25131     } catch (...) {
25132       {
25133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25134       };
25135     }
25136   }
25137
25138 }
25139
25140
25141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25142   void * jresult ;
25143   Dali::TextureSet *arg1 = 0 ;
25144   Dali::TextureSet *result = 0 ;
25145
25146   arg1 = (Dali::TextureSet *)jarg1;
25147   if (!arg1) {
25148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25149     return 0;
25150   }
25151   {
25152     try {
25153       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25154     } catch (std::out_of_range& e) {
25155       {
25156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25157       };
25158     } catch (std::exception& e) {
25159       {
25160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25161       };
25162     } catch (Dali::DaliException e) {
25163       {
25164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25165       };
25166     } catch (...) {
25167       {
25168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25169       };
25170     }
25171   }
25172
25173   jresult = (void *)result;
25174   return jresult;
25175 }
25176
25177
25178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25179   void * jresult ;
25180   Dali::BaseHandle arg1 ;
25181   Dali::BaseHandle *argp1 ;
25182   Dali::TextureSet result;
25183
25184   argp1 = (Dali::BaseHandle *)jarg1;
25185   if (!argp1) {
25186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25187     return 0;
25188   }
25189   arg1 = *argp1;
25190   {
25191     try {
25192       result = Dali::TextureSet::DownCast(arg1);
25193     } catch (std::out_of_range& e) {
25194       {
25195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25196       };
25197     } catch (std::exception& e) {
25198       {
25199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25200       };
25201     } catch (Dali::DaliException e) {
25202       {
25203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25204       };
25205     } catch (...) {
25206       {
25207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25208       };
25209     }
25210   }
25211
25212   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25213   return jresult;
25214 }
25215
25216
25217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25218   void * jresult ;
25219   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25220   Dali::TextureSet *arg2 = 0 ;
25221   Dali::TextureSet *result = 0 ;
25222
25223   arg1 = (Dali::TextureSet *)jarg1;
25224   arg2 = (Dali::TextureSet *)jarg2;
25225   if (!arg2) {
25226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25227     return 0;
25228   }
25229   {
25230     try {
25231       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25232     } catch (std::out_of_range& e) {
25233       {
25234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25235       };
25236     } catch (std::exception& e) {
25237       {
25238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25239       };
25240     } catch (Dali::DaliException e) {
25241       {
25242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25243       };
25244     } catch (...) {
25245       {
25246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25247       };
25248     }
25249   }
25250
25251   jresult = (void *)result;
25252   return jresult;
25253 }
25254
25255
25256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25257   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25258   size_t arg2 ;
25259   Dali::Texture arg3 ;
25260   Dali::Texture *argp3 ;
25261
25262   arg1 = (Dali::TextureSet *)jarg1;
25263   arg2 = (size_t)jarg2;
25264   argp3 = (Dali::Texture *)jarg3;
25265   if (!argp3) {
25266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25267     return ;
25268   }
25269   arg3 = *argp3;
25270   {
25271     try {
25272       (arg1)->SetTexture(arg2,arg3);
25273     } catch (std::out_of_range& e) {
25274       {
25275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25276       };
25277     } catch (std::exception& e) {
25278       {
25279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25280       };
25281     } catch (Dali::DaliException e) {
25282       {
25283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25284       };
25285     } catch (...) {
25286       {
25287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25288       };
25289     }
25290   }
25291
25292 }
25293
25294
25295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25296   void * jresult ;
25297   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25298   size_t arg2 ;
25299   Dali::Texture result;
25300
25301   arg1 = (Dali::TextureSet *)jarg1;
25302   arg2 = (size_t)jarg2;
25303   {
25304     try {
25305       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25306     } catch (std::out_of_range& e) {
25307       {
25308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25309       };
25310     } catch (std::exception& e) {
25311       {
25312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25313       };
25314     } catch (Dali::DaliException e) {
25315       {
25316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25317       };
25318     } catch (...) {
25319       {
25320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25321       };
25322     }
25323   }
25324
25325   jresult = new Dali::Texture((const Dali::Texture &)result);
25326   return jresult;
25327 }
25328
25329
25330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25331   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25332   size_t arg2 ;
25333   Dali::Sampler arg3 ;
25334   Dali::Sampler *argp3 ;
25335
25336   arg1 = (Dali::TextureSet *)jarg1;
25337   arg2 = (size_t)jarg2;
25338   argp3 = (Dali::Sampler *)jarg3;
25339   if (!argp3) {
25340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25341     return ;
25342   }
25343   arg3 = *argp3;
25344   {
25345     try {
25346       (arg1)->SetSampler(arg2,arg3);
25347     } catch (std::out_of_range& e) {
25348       {
25349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25350       };
25351     } catch (std::exception& e) {
25352       {
25353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25354       };
25355     } catch (Dali::DaliException e) {
25356       {
25357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25358       };
25359     } catch (...) {
25360       {
25361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25362       };
25363     }
25364   }
25365
25366 }
25367
25368
25369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25370   void * jresult ;
25371   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25372   size_t arg2 ;
25373   Dali::Sampler result;
25374
25375   arg1 = (Dali::TextureSet *)jarg1;
25376   arg2 = (size_t)jarg2;
25377   {
25378     try {
25379       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25380     } catch (std::out_of_range& e) {
25381       {
25382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25383       };
25384     } catch (std::exception& e) {
25385       {
25386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25387       };
25388     } catch (Dali::DaliException e) {
25389       {
25390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25391       };
25392     } catch (...) {
25393       {
25394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25395       };
25396     }
25397   }
25398
25399   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25400   return jresult;
25401 }
25402
25403
25404 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25405   unsigned long jresult ;
25406   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25407   size_t result;
25408
25409   arg1 = (Dali::TextureSet *)jarg1;
25410   {
25411     try {
25412       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25413     } catch (std::out_of_range& e) {
25414       {
25415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25416       };
25417     } catch (std::exception& e) {
25418       {
25419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25420       };
25421     } catch (Dali::DaliException e) {
25422       {
25423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25424       };
25425     } catch (...) {
25426       {
25427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25428       };
25429     }
25430   }
25431
25432   jresult = (unsigned long)result;
25433   return jresult;
25434 }
25435
25436
25437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25438   void * jresult ;
25439   Dali::Property::Map *arg1 = 0 ;
25440   Dali::PropertyBuffer result;
25441
25442   arg1 = (Dali::Property::Map *)jarg1;
25443   if (!arg1) {
25444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25445     return 0;
25446   }
25447   {
25448     try {
25449       result = Dali::PropertyBuffer::New(*arg1);
25450     } catch (std::out_of_range& e) {
25451       {
25452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25453       };
25454     } catch (std::exception& e) {
25455       {
25456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25457       };
25458     } catch (Dali::DaliException e) {
25459       {
25460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25461       };
25462     } catch (...) {
25463       {
25464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25465       };
25466     }
25467   }
25468
25469   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25470   return jresult;
25471 }
25472
25473
25474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25475   void * jresult ;
25476   Dali::PropertyBuffer *result = 0 ;
25477
25478   {
25479     try {
25480       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25481     } catch (std::out_of_range& e) {
25482       {
25483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25484       };
25485     } catch (std::exception& e) {
25486       {
25487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25488       };
25489     } catch (Dali::DaliException e) {
25490       {
25491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25492       };
25493     } catch (...) {
25494       {
25495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25496       };
25497     }
25498   }
25499
25500   jresult = (void *)result;
25501   return jresult;
25502 }
25503
25504
25505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25506   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25507
25508   arg1 = (Dali::PropertyBuffer *)jarg1;
25509   {
25510     try {
25511       delete arg1;
25512     } catch (std::out_of_range& e) {
25513       {
25514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25515       };
25516     } catch (std::exception& e) {
25517       {
25518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25519       };
25520     } catch (Dali::DaliException e) {
25521       {
25522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25523       };
25524     } catch (...) {
25525       {
25526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25527       };
25528     }
25529   }
25530
25531 }
25532
25533
25534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25535   void * jresult ;
25536   Dali::PropertyBuffer *arg1 = 0 ;
25537   Dali::PropertyBuffer *result = 0 ;
25538
25539   arg1 = (Dali::PropertyBuffer *)jarg1;
25540   if (!arg1) {
25541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25542     return 0;
25543   }
25544   {
25545     try {
25546       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25547     } catch (std::out_of_range& e) {
25548       {
25549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25550       };
25551     } catch (std::exception& e) {
25552       {
25553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25554       };
25555     } catch (Dali::DaliException e) {
25556       {
25557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25558       };
25559     } catch (...) {
25560       {
25561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25562       };
25563     }
25564   }
25565
25566   jresult = (void *)result;
25567   return jresult;
25568 }
25569
25570
25571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25572   void * jresult ;
25573   Dali::BaseHandle arg1 ;
25574   Dali::BaseHandle *argp1 ;
25575   Dali::PropertyBuffer result;
25576
25577   argp1 = (Dali::BaseHandle *)jarg1;
25578   if (!argp1) {
25579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25580     return 0;
25581   }
25582   arg1 = *argp1;
25583   {
25584     try {
25585       result = Dali::PropertyBuffer::DownCast(arg1);
25586     } catch (std::out_of_range& e) {
25587       {
25588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25589       };
25590     } catch (std::exception& e) {
25591       {
25592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25593       };
25594     } catch (Dali::DaliException e) {
25595       {
25596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25597       };
25598     } catch (...) {
25599       {
25600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25601       };
25602     }
25603   }
25604
25605   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25606   return jresult;
25607 }
25608
25609
25610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25611   void * jresult ;
25612   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25613   Dali::PropertyBuffer *arg2 = 0 ;
25614   Dali::PropertyBuffer *result = 0 ;
25615
25616   arg1 = (Dali::PropertyBuffer *)jarg1;
25617   arg2 = (Dali::PropertyBuffer *)jarg2;
25618   if (!arg2) {
25619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25620     return 0;
25621   }
25622   {
25623     try {
25624       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25625     } catch (std::out_of_range& e) {
25626       {
25627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25628       };
25629     } catch (std::exception& e) {
25630       {
25631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25632       };
25633     } catch (Dali::DaliException e) {
25634       {
25635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25636       };
25637     } catch (...) {
25638       {
25639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25640       };
25641     }
25642   }
25643
25644   jresult = (void *)result;
25645   return jresult;
25646 }
25647
25648
25649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25650   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25651   void *arg2 = (void *) 0 ;
25652   std::size_t arg3 ;
25653
25654   arg1 = (Dali::PropertyBuffer *)jarg1;
25655   arg2 = jarg2;
25656   arg3 = (std::size_t)jarg3;
25657   {
25658     try {
25659       (arg1)->SetData((void const *)arg2,arg3);
25660     } catch (std::out_of_range& e) {
25661       {
25662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25663       };
25664     } catch (std::exception& e) {
25665       {
25666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25667       };
25668     } catch (Dali::DaliException e) {
25669       {
25670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25671       };
25672     } catch (...) {
25673       {
25674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25675       };
25676     }
25677   }
25678
25679 }
25680
25681
25682 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25683   unsigned long jresult ;
25684   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25685   std::size_t result;
25686
25687   arg1 = (Dali::PropertyBuffer *)jarg1;
25688   {
25689     try {
25690       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25691     } catch (std::out_of_range& e) {
25692       {
25693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25694       };
25695     } catch (std::exception& e) {
25696       {
25697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25698       };
25699     } catch (Dali::DaliException e) {
25700       {
25701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25702       };
25703     } catch (...) {
25704       {
25705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25706       };
25707     }
25708   }
25709
25710   jresult = (unsigned long)result;
25711   return jresult;
25712 }
25713
25714
25715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25716   void * jresult ;
25717   Dali::Geometry result;
25718
25719   {
25720     try {
25721       result = Dali::Geometry::New();
25722     } catch (std::out_of_range& e) {
25723       {
25724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25725       };
25726     } catch (std::exception& e) {
25727       {
25728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25729       };
25730     } catch (Dali::DaliException e) {
25731       {
25732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25733       };
25734     } catch (...) {
25735       {
25736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25737       };
25738     }
25739   }
25740
25741   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25742   return jresult;
25743 }
25744
25745
25746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25747   void * jresult ;
25748   Dali::Geometry *result = 0 ;
25749
25750   {
25751     try {
25752       result = (Dali::Geometry *)new Dali::Geometry();
25753     } catch (std::out_of_range& e) {
25754       {
25755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25756       };
25757     } catch (std::exception& e) {
25758       {
25759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25760       };
25761     } catch (Dali::DaliException e) {
25762       {
25763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25764       };
25765     } catch (...) {
25766       {
25767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25768       };
25769     }
25770   }
25771
25772   jresult = (void *)result;
25773   return jresult;
25774 }
25775
25776
25777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25778   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25779
25780   arg1 = (Dali::Geometry *)jarg1;
25781   {
25782     try {
25783       delete arg1;
25784     } catch (std::out_of_range& e) {
25785       {
25786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25787       };
25788     } catch (std::exception& e) {
25789       {
25790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25791       };
25792     } catch (Dali::DaliException e) {
25793       {
25794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25795       };
25796     } catch (...) {
25797       {
25798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25799       };
25800     }
25801   }
25802
25803 }
25804
25805
25806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25807   void * jresult ;
25808   Dali::Geometry *arg1 = 0 ;
25809   Dali::Geometry *result = 0 ;
25810
25811   arg1 = (Dali::Geometry *)jarg1;
25812   if (!arg1) {
25813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25814     return 0;
25815   }
25816   {
25817     try {
25818       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25819     } catch (std::out_of_range& e) {
25820       {
25821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25822       };
25823     } catch (std::exception& e) {
25824       {
25825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25826       };
25827     } catch (Dali::DaliException e) {
25828       {
25829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25830       };
25831     } catch (...) {
25832       {
25833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25834       };
25835     }
25836   }
25837
25838   jresult = (void *)result;
25839   return jresult;
25840 }
25841
25842
25843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25844   void * jresult ;
25845   Dali::BaseHandle arg1 ;
25846   Dali::BaseHandle *argp1 ;
25847   Dali::Geometry result;
25848
25849   argp1 = (Dali::BaseHandle *)jarg1;
25850   if (!argp1) {
25851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25852     return 0;
25853   }
25854   arg1 = *argp1;
25855   {
25856     try {
25857       result = Dali::Geometry::DownCast(arg1);
25858     } catch (std::out_of_range& e) {
25859       {
25860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25861       };
25862     } catch (std::exception& e) {
25863       {
25864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25865       };
25866     } catch (Dali::DaliException e) {
25867       {
25868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25869       };
25870     } catch (...) {
25871       {
25872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25873       };
25874     }
25875   }
25876
25877   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25878   return jresult;
25879 }
25880
25881
25882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25883   void * jresult ;
25884   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25885   Dali::Geometry *arg2 = 0 ;
25886   Dali::Geometry *result = 0 ;
25887
25888   arg1 = (Dali::Geometry *)jarg1;
25889   arg2 = (Dali::Geometry *)jarg2;
25890   if (!arg2) {
25891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25892     return 0;
25893   }
25894   {
25895     try {
25896       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25897     } catch (std::out_of_range& e) {
25898       {
25899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25900       };
25901     } catch (std::exception& e) {
25902       {
25903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25904       };
25905     } catch (Dali::DaliException e) {
25906       {
25907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25908       };
25909     } catch (...) {
25910       {
25911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25912       };
25913     }
25914   }
25915
25916   jresult = (void *)result;
25917   return jresult;
25918 }
25919
25920
25921 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25922   unsigned long jresult ;
25923   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25924   Dali::PropertyBuffer *arg2 = 0 ;
25925   std::size_t result;
25926
25927   arg1 = (Dali::Geometry *)jarg1;
25928   arg2 = (Dali::PropertyBuffer *)jarg2;
25929   if (!arg2) {
25930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25931     return 0;
25932   }
25933   {
25934     try {
25935       result = (arg1)->AddVertexBuffer(*arg2);
25936     } catch (std::out_of_range& e) {
25937       {
25938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25939       };
25940     } catch (std::exception& e) {
25941       {
25942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25943       };
25944     } catch (Dali::DaliException e) {
25945       {
25946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25947       };
25948     } catch (...) {
25949       {
25950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25951       };
25952     }
25953   }
25954
25955   jresult = (unsigned long)result;
25956   return jresult;
25957 }
25958
25959
25960 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25961   unsigned long jresult ;
25962   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25963   std::size_t result;
25964
25965   arg1 = (Dali::Geometry *)jarg1;
25966   {
25967     try {
25968       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25969     } catch (std::out_of_range& e) {
25970       {
25971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25972       };
25973     } catch (std::exception& e) {
25974       {
25975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25976       };
25977     } catch (Dali::DaliException e) {
25978       {
25979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25980       };
25981     } catch (...) {
25982       {
25983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25984       };
25985     }
25986   }
25987
25988   jresult = (unsigned long)result;
25989   return jresult;
25990 }
25991
25992
25993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25994   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25995   std::size_t arg2 ;
25996
25997   arg1 = (Dali::Geometry *)jarg1;
25998   arg2 = (std::size_t)jarg2;
25999   {
26000     try {
26001       (arg1)->RemoveVertexBuffer(arg2);
26002     } catch (std::out_of_range& e) {
26003       {
26004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26005       };
26006     } catch (std::exception& e) {
26007       {
26008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26009       };
26010     } catch (Dali::DaliException e) {
26011       {
26012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26013       };
26014     } catch (...) {
26015       {
26016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26017       };
26018     }
26019   }
26020
26021 }
26022
26023
26024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26025   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26026   unsigned short *arg2 = (unsigned short *) 0 ;
26027   size_t arg3 ;
26028
26029   arg1 = (Dali::Geometry *)jarg1;
26030   arg2 = jarg2;
26031   arg3 = (size_t)jarg3;
26032   {
26033     try {
26034       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26035     } catch (std::out_of_range& e) {
26036       {
26037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26038       };
26039     } catch (std::exception& e) {
26040       {
26041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26042       };
26043     } catch (Dali::DaliException e) {
26044       {
26045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26046       };
26047     } catch (...) {
26048       {
26049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26050       };
26051     }
26052   }
26053
26054
26055
26056 }
26057
26058
26059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26060   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26061   Dali::Geometry::Type arg2 ;
26062
26063   arg1 = (Dali::Geometry *)jarg1;
26064   arg2 = (Dali::Geometry::Type)jarg2;
26065   {
26066     try {
26067       (arg1)->SetType(arg2);
26068     } catch (std::out_of_range& e) {
26069       {
26070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26071       };
26072     } catch (std::exception& e) {
26073       {
26074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26075       };
26076     } catch (Dali::DaliException e) {
26077       {
26078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26079       };
26080     } catch (...) {
26081       {
26082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26083       };
26084     }
26085   }
26086
26087 }
26088
26089
26090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26091   int jresult ;
26092   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26093   Dali::Geometry::Type result;
26094
26095   arg1 = (Dali::Geometry *)jarg1;
26096   {
26097     try {
26098       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26099     } catch (std::out_of_range& e) {
26100       {
26101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26102       };
26103     } catch (std::exception& e) {
26104       {
26105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26106       };
26107     } catch (Dali::DaliException e) {
26108       {
26109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26110       };
26111     } catch (...) {
26112       {
26113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26114       };
26115     }
26116   }
26117
26118   jresult = (int)result;
26119   return jresult;
26120 }
26121
26122
26123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26124   void * jresult ;
26125   Dali::Shader::Hint *result = 0 ;
26126
26127   {
26128     try {
26129       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26130     } catch (std::out_of_range& e) {
26131       {
26132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26133       };
26134     } catch (std::exception& e) {
26135       {
26136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26137       };
26138     } catch (Dali::DaliException e) {
26139       {
26140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26141       };
26142     } catch (...) {
26143       {
26144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26145       };
26146     }
26147   }
26148
26149   jresult = (void *)result;
26150   return jresult;
26151 }
26152
26153
26154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26155   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26156
26157   arg1 = (Dali::Shader::Hint *)jarg1;
26158   {
26159     try {
26160       delete arg1;
26161     } catch (std::out_of_range& e) {
26162       {
26163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26164       };
26165     } catch (std::exception& e) {
26166       {
26167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26168       };
26169     } catch (Dali::DaliException e) {
26170       {
26171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26172       };
26173     } catch (...) {
26174       {
26175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26176       };
26177     }
26178   }
26179
26180 }
26181
26182
26183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26184   int jresult ;
26185   int result;
26186
26187   result = (int)Dali::Shader::Property::PROGRAM;
26188   jresult = (int)result;
26189   return jresult;
26190 }
26191
26192
26193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26194   void * jresult ;
26195   Dali::Shader::Property *result = 0 ;
26196
26197   {
26198     try {
26199       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26200     } catch (std::out_of_range& e) {
26201       {
26202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26203       };
26204     } catch (std::exception& e) {
26205       {
26206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26207       };
26208     } catch (Dali::DaliException e) {
26209       {
26210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26211       };
26212     } catch (...) {
26213       {
26214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26215       };
26216     }
26217   }
26218
26219   jresult = (void *)result;
26220   return jresult;
26221 }
26222
26223
26224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26225   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26226
26227   arg1 = (Dali::Shader::Property *)jarg1;
26228   {
26229     try {
26230       delete arg1;
26231     } catch (std::out_of_range& e) {
26232       {
26233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26234       };
26235     } catch (std::exception& e) {
26236       {
26237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26238       };
26239     } catch (Dali::DaliException e) {
26240       {
26241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26242       };
26243     } catch (...) {
26244       {
26245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26246       };
26247     }
26248   }
26249
26250 }
26251
26252
26253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26254   void * jresult ;
26255   std::string *arg1 = 0 ;
26256   std::string *arg2 = 0 ;
26257   Dali::Shader::Hint::Value arg3 ;
26258   Dali::Shader result;
26259
26260   if (!jarg1) {
26261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26262     return 0;
26263   }
26264   std::string arg1_str(jarg1);
26265   arg1 = &arg1_str;
26266   if (!jarg2) {
26267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26268     return 0;
26269   }
26270   std::string arg2_str(jarg2);
26271   arg2 = &arg2_str;
26272   arg3 = (Dali::Shader::Hint::Value)jarg3;
26273   {
26274     try {
26275       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26276     } catch (std::out_of_range& e) {
26277       {
26278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26279       };
26280     } catch (std::exception& e) {
26281       {
26282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26283       };
26284     } catch (Dali::DaliException e) {
26285       {
26286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26287       };
26288     } catch (...) {
26289       {
26290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26291       };
26292     }
26293   }
26294
26295   jresult = new Dali::Shader((const Dali::Shader &)result);
26296
26297   //argout typemap for const std::string&
26298
26299
26300   //argout typemap for const std::string&
26301
26302   return jresult;
26303 }
26304
26305
26306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26307   void * jresult ;
26308   std::string *arg1 = 0 ;
26309   std::string *arg2 = 0 ;
26310   Dali::Shader result;
26311
26312   if (!jarg1) {
26313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26314     return 0;
26315   }
26316   std::string arg1_str(jarg1);
26317   arg1 = &arg1_str;
26318   if (!jarg2) {
26319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26320     return 0;
26321   }
26322   std::string arg2_str(jarg2);
26323   arg2 = &arg2_str;
26324   {
26325     try {
26326       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26327     } catch (std::out_of_range& e) {
26328       {
26329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26330       };
26331     } catch (std::exception& e) {
26332       {
26333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26334       };
26335     } catch (Dali::DaliException e) {
26336       {
26337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26338       };
26339     } catch (...) {
26340       {
26341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26342       };
26343     }
26344   }
26345
26346   jresult = new Dali::Shader((const Dali::Shader &)result);
26347
26348   //argout typemap for const std::string&
26349
26350
26351   //argout typemap for const std::string&
26352
26353   return jresult;
26354 }
26355
26356
26357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26358   void * jresult ;
26359   Dali::Shader *result = 0 ;
26360
26361   {
26362     try {
26363       result = (Dali::Shader *)new Dali::Shader();
26364     } catch (std::out_of_range& e) {
26365       {
26366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26367       };
26368     } catch (std::exception& e) {
26369       {
26370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26371       };
26372     } catch (Dali::DaliException e) {
26373       {
26374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26375       };
26376     } catch (...) {
26377       {
26378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26379       };
26380     }
26381   }
26382
26383   jresult = (void *)result;
26384   return jresult;
26385 }
26386
26387
26388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26389   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26390
26391   arg1 = (Dali::Shader *)jarg1;
26392   {
26393     try {
26394       delete arg1;
26395     } catch (std::out_of_range& e) {
26396       {
26397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26398       };
26399     } catch (std::exception& e) {
26400       {
26401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26402       };
26403     } catch (Dali::DaliException e) {
26404       {
26405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26406       };
26407     } catch (...) {
26408       {
26409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26410       };
26411     }
26412   }
26413
26414 }
26415
26416
26417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26418   void * jresult ;
26419   Dali::Shader *arg1 = 0 ;
26420   Dali::Shader *result = 0 ;
26421
26422   arg1 = (Dali::Shader *)jarg1;
26423   if (!arg1) {
26424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26425     return 0;
26426   }
26427   {
26428     try {
26429       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26430     } catch (std::out_of_range& e) {
26431       {
26432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26433       };
26434     } catch (std::exception& e) {
26435       {
26436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26437       };
26438     } catch (Dali::DaliException e) {
26439       {
26440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26441       };
26442     } catch (...) {
26443       {
26444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26445       };
26446     }
26447   }
26448
26449   jresult = (void *)result;
26450   return jresult;
26451 }
26452
26453
26454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26455   void * jresult ;
26456   Dali::BaseHandle arg1 ;
26457   Dali::BaseHandle *argp1 ;
26458   Dali::Shader result;
26459
26460   argp1 = (Dali::BaseHandle *)jarg1;
26461   if (!argp1) {
26462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26463     return 0;
26464   }
26465   arg1 = *argp1;
26466   {
26467     try {
26468       result = Dali::Shader::DownCast(arg1);
26469     } catch (std::out_of_range& e) {
26470       {
26471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26472       };
26473     } catch (std::exception& e) {
26474       {
26475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26476       };
26477     } catch (Dali::DaliException e) {
26478       {
26479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26480       };
26481     } catch (...) {
26482       {
26483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26484       };
26485     }
26486   }
26487
26488   jresult = new Dali::Shader((const Dali::Shader &)result);
26489   return jresult;
26490 }
26491
26492
26493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26494   void * jresult ;
26495   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26496   Dali::Shader *arg2 = 0 ;
26497   Dali::Shader *result = 0 ;
26498
26499   arg1 = (Dali::Shader *)jarg1;
26500   arg2 = (Dali::Shader *)jarg2;
26501   if (!arg2) {
26502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26503     return 0;
26504   }
26505   {
26506     try {
26507       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26508     } catch (std::out_of_range& e) {
26509       {
26510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26511       };
26512     } catch (std::exception& e) {
26513       {
26514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26515       };
26516     } catch (Dali::DaliException e) {
26517       {
26518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26519       };
26520     } catch (...) {
26521       {
26522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26523       };
26524     }
26525   }
26526
26527   jresult = (void *)result;
26528   return jresult;
26529 }
26530
26531
26532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26533   int jresult ;
26534   int result;
26535
26536   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26537   jresult = (int)result;
26538   return jresult;
26539 }
26540
26541
26542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26543   int jresult ;
26544   int result;
26545
26546   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26547   jresult = (int)result;
26548   return jresult;
26549 }
26550
26551
26552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26553   int jresult ;
26554   int result;
26555
26556   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26557   jresult = (int)result;
26558   return jresult;
26559 }
26560
26561
26562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26563   int jresult ;
26564   int result;
26565
26566   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26567   jresult = (int)result;
26568   return jresult;
26569 }
26570
26571
26572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26573   int jresult ;
26574   int result;
26575
26576   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26577   jresult = (int)result;
26578   return jresult;
26579 }
26580
26581
26582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26583   int jresult ;
26584   int result;
26585
26586   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26587   jresult = (int)result;
26588   return jresult;
26589 }
26590
26591
26592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26593   int jresult ;
26594   int result;
26595
26596   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26597   jresult = (int)result;
26598   return jresult;
26599 }
26600
26601
26602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26603   int jresult ;
26604   int result;
26605
26606   result = (int)Dali::Renderer::Property::BLEND_MODE;
26607   jresult = (int)result;
26608   return jresult;
26609 }
26610
26611
26612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26613   int jresult ;
26614   int result;
26615
26616   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26617   jresult = (int)result;
26618   return jresult;
26619 }
26620
26621
26622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26623   int jresult ;
26624   int result;
26625
26626   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26627   jresult = (int)result;
26628   return jresult;
26629 }
26630
26631
26632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26633   int jresult ;
26634   int result;
26635
26636   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26637   jresult = (int)result;
26638   return jresult;
26639 }
26640
26641
26642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26643   int jresult ;
26644   int result;
26645
26646   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26647   jresult = (int)result;
26648   return jresult;
26649 }
26650
26651
26652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26653   int jresult ;
26654   int result;
26655
26656   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26657   jresult = (int)result;
26658   return jresult;
26659 }
26660
26661
26662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26663   int jresult ;
26664   int result;
26665
26666   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26667   jresult = (int)result;
26668   return jresult;
26669 }
26670
26671
26672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26673   int jresult ;
26674   int result;
26675
26676   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26677   jresult = (int)result;
26678   return jresult;
26679 }
26680
26681
26682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26683   int jresult ;
26684   int result;
26685
26686   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26687   jresult = (int)result;
26688   return jresult;
26689 }
26690
26691
26692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26693   int jresult ;
26694   int result;
26695
26696   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26697   jresult = (int)result;
26698   return jresult;
26699 }
26700
26701
26702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26703   int jresult ;
26704   int result;
26705
26706   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26707   jresult = (int)result;
26708   return jresult;
26709 }
26710
26711
26712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26713   int jresult ;
26714   int result;
26715
26716   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26717   jresult = (int)result;
26718   return jresult;
26719 }
26720
26721
26722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26723   int jresult ;
26724   int result;
26725
26726   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26727   jresult = (int)result;
26728   return jresult;
26729 }
26730
26731
26732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26733   int jresult ;
26734   int result;
26735
26736   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26737   jresult = (int)result;
26738   return jresult;
26739 }
26740
26741
26742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26743   int jresult ;
26744   int result;
26745
26746   result = (int)Dali::Renderer::Property::RENDER_MODE;
26747   jresult = (int)result;
26748   return jresult;
26749 }
26750
26751
26752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26753   int jresult ;
26754   int result;
26755
26756   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26757   jresult = (int)result;
26758   return jresult;
26759 }
26760
26761
26762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26763   int jresult ;
26764   int result;
26765
26766   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26767   jresult = (int)result;
26768   return jresult;
26769 }
26770
26771
26772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26773   int jresult ;
26774   int result;
26775
26776   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26777   jresult = (int)result;
26778   return jresult;
26779 }
26780
26781
26782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26783   int jresult ;
26784   int result;
26785
26786   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26787   jresult = (int)result;
26788   return jresult;
26789 }
26790
26791
26792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26793   int jresult ;
26794   int result;
26795
26796   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26797   jresult = (int)result;
26798   return jresult;
26799 }
26800
26801
26802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26803   int jresult ;
26804   int result;
26805
26806   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26807   jresult = (int)result;
26808   return jresult;
26809 }
26810
26811
26812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26813   int jresult ;
26814   int result;
26815
26816   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26817   jresult = (int)result;
26818   return jresult;
26819 }
26820
26821
26822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26823   void * jresult ;
26824   Dali::Renderer::Property *result = 0 ;
26825
26826   {
26827     try {
26828       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26829     } catch (std::out_of_range& e) {
26830       {
26831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26832       };
26833     } catch (std::exception& e) {
26834       {
26835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26836       };
26837     } catch (Dali::DaliException e) {
26838       {
26839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26840       };
26841     } catch (...) {
26842       {
26843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26844       };
26845     }
26846   }
26847
26848   jresult = (void *)result;
26849   return jresult;
26850 }
26851
26852
26853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26854   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26855
26856   arg1 = (Dali::Renderer::Property *)jarg1;
26857   {
26858     try {
26859       delete arg1;
26860     } catch (std::out_of_range& e) {
26861       {
26862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26863       };
26864     } catch (std::exception& e) {
26865       {
26866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26867       };
26868     } catch (Dali::DaliException e) {
26869       {
26870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26871       };
26872     } catch (...) {
26873       {
26874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26875       };
26876     }
26877   }
26878
26879 }
26880
26881
26882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26883   void * jresult ;
26884   Dali::Geometry *arg1 = 0 ;
26885   Dali::Shader *arg2 = 0 ;
26886   Dali::Renderer result;
26887
26888   arg1 = (Dali::Geometry *)jarg1;
26889   if (!arg1) {
26890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26891     return 0;
26892   }
26893   arg2 = (Dali::Shader *)jarg2;
26894   if (!arg2) {
26895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26896     return 0;
26897   }
26898   {
26899     try {
26900       result = Dali::Renderer::New(*arg1,*arg2);
26901     } catch (std::out_of_range& e) {
26902       {
26903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26904       };
26905     } catch (std::exception& e) {
26906       {
26907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26908       };
26909     } catch (Dali::DaliException e) {
26910       {
26911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26912       };
26913     } catch (...) {
26914       {
26915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26916       };
26917     }
26918   }
26919
26920   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26921   return jresult;
26922 }
26923
26924
26925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26926   void * jresult ;
26927   Dali::Renderer *result = 0 ;
26928
26929   {
26930     try {
26931       result = (Dali::Renderer *)new Dali::Renderer();
26932     } catch (std::out_of_range& e) {
26933       {
26934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26935       };
26936     } catch (std::exception& e) {
26937       {
26938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26939       };
26940     } catch (Dali::DaliException e) {
26941       {
26942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26943       };
26944     } catch (...) {
26945       {
26946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26947       };
26948     }
26949   }
26950
26951   jresult = (void *)result;
26952   return jresult;
26953 }
26954
26955
26956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26957   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26958
26959   arg1 = (Dali::Renderer *)jarg1;
26960   {
26961     try {
26962       delete arg1;
26963     } catch (std::out_of_range& e) {
26964       {
26965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26966       };
26967     } catch (std::exception& e) {
26968       {
26969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26970       };
26971     } catch (Dali::DaliException e) {
26972       {
26973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26974       };
26975     } catch (...) {
26976       {
26977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26978       };
26979     }
26980   }
26981
26982 }
26983
26984
26985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26986   void * jresult ;
26987   Dali::Renderer *arg1 = 0 ;
26988   Dali::Renderer *result = 0 ;
26989
26990   arg1 = (Dali::Renderer *)jarg1;
26991   if (!arg1) {
26992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26993     return 0;
26994   }
26995   {
26996     try {
26997       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26998     } catch (std::out_of_range& e) {
26999       {
27000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27001       };
27002     } catch (std::exception& e) {
27003       {
27004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27005       };
27006     } catch (Dali::DaliException e) {
27007       {
27008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27009       };
27010     } catch (...) {
27011       {
27012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27013       };
27014     }
27015   }
27016
27017   jresult = (void *)result;
27018   return jresult;
27019 }
27020
27021
27022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27023   void * jresult ;
27024   Dali::BaseHandle arg1 ;
27025   Dali::BaseHandle *argp1 ;
27026   Dali::Renderer result;
27027
27028   argp1 = (Dali::BaseHandle *)jarg1;
27029   if (!argp1) {
27030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27031     return 0;
27032   }
27033   arg1 = *argp1;
27034   {
27035     try {
27036       result = Dali::Renderer::DownCast(arg1);
27037     } catch (std::out_of_range& e) {
27038       {
27039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27040       };
27041     } catch (std::exception& e) {
27042       {
27043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27044       };
27045     } catch (Dali::DaliException e) {
27046       {
27047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27048       };
27049     } catch (...) {
27050       {
27051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27052       };
27053     }
27054   }
27055
27056   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27057   return jresult;
27058 }
27059
27060
27061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27062   void * jresult ;
27063   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27064   Dali::Renderer *arg2 = 0 ;
27065   Dali::Renderer *result = 0 ;
27066
27067   arg1 = (Dali::Renderer *)jarg1;
27068   arg2 = (Dali::Renderer *)jarg2;
27069   if (!arg2) {
27070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27071     return 0;
27072   }
27073   {
27074     try {
27075       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27076     } catch (std::out_of_range& e) {
27077       {
27078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27079       };
27080     } catch (std::exception& e) {
27081       {
27082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27083       };
27084     } catch (Dali::DaliException e) {
27085       {
27086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27087       };
27088     } catch (...) {
27089       {
27090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27091       };
27092     }
27093   }
27094
27095   jresult = (void *)result;
27096   return jresult;
27097 }
27098
27099
27100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27101   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27102   Dali::Geometry *arg2 = 0 ;
27103
27104   arg1 = (Dali::Renderer *)jarg1;
27105   arg2 = (Dali::Geometry *)jarg2;
27106   if (!arg2) {
27107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27108     return ;
27109   }
27110   {
27111     try {
27112       (arg1)->SetGeometry(*arg2);
27113     } catch (std::out_of_range& e) {
27114       {
27115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27116       };
27117     } catch (std::exception& e) {
27118       {
27119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27120       };
27121     } catch (Dali::DaliException e) {
27122       {
27123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27124       };
27125     } catch (...) {
27126       {
27127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27128       };
27129     }
27130   }
27131
27132 }
27133
27134
27135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27136   void * jresult ;
27137   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27138   Dali::Geometry result;
27139
27140   arg1 = (Dali::Renderer *)jarg1;
27141   {
27142     try {
27143       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27144     } catch (std::out_of_range& e) {
27145       {
27146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27147       };
27148     } catch (std::exception& e) {
27149       {
27150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27151       };
27152     } catch (Dali::DaliException e) {
27153       {
27154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27155       };
27156     } catch (...) {
27157       {
27158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27159       };
27160     }
27161   }
27162
27163   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27164   return jresult;
27165 }
27166
27167
27168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27169   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27170   int arg2 ;
27171   int arg3 ;
27172
27173   arg1 = (Dali::Renderer *)jarg1;
27174   arg2 = (int)jarg2;
27175   arg3 = (int)jarg3;
27176   {
27177     try {
27178       (arg1)->SetIndexRange(arg2,arg3);
27179     } catch (std::out_of_range& e) {
27180       {
27181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27182       };
27183     } catch (std::exception& e) {
27184       {
27185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27186       };
27187     } catch (Dali::DaliException e) {
27188       {
27189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27190       };
27191     } catch (...) {
27192       {
27193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27194       };
27195     }
27196   }
27197
27198 }
27199
27200
27201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27202   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27203   Dali::TextureSet *arg2 = 0 ;
27204
27205   arg1 = (Dali::Renderer *)jarg1;
27206   arg2 = (Dali::TextureSet *)jarg2;
27207   if (!arg2) {
27208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27209     return ;
27210   }
27211   {
27212     try {
27213       (arg1)->SetTextures(*arg2);
27214     } catch (std::out_of_range& e) {
27215       {
27216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27217       };
27218     } catch (std::exception& e) {
27219       {
27220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27221       };
27222     } catch (Dali::DaliException e) {
27223       {
27224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27225       };
27226     } catch (...) {
27227       {
27228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27229       };
27230     }
27231   }
27232
27233 }
27234
27235
27236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27237   void * jresult ;
27238   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27239   Dali::TextureSet result;
27240
27241   arg1 = (Dali::Renderer *)jarg1;
27242   {
27243     try {
27244       result = ((Dali::Renderer const *)arg1)->GetTextures();
27245     } catch (std::out_of_range& e) {
27246       {
27247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27248       };
27249     } catch (std::exception& e) {
27250       {
27251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27252       };
27253     } catch (Dali::DaliException e) {
27254       {
27255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27256       };
27257     } catch (...) {
27258       {
27259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27260       };
27261     }
27262   }
27263
27264   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27265   return jresult;
27266 }
27267
27268
27269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27270   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27271   Dali::Shader *arg2 = 0 ;
27272
27273   arg1 = (Dali::Renderer *)jarg1;
27274   arg2 = (Dali::Shader *)jarg2;
27275   if (!arg2) {
27276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27277     return ;
27278   }
27279   {
27280     try {
27281       (arg1)->SetShader(*arg2);
27282     } catch (std::out_of_range& e) {
27283       {
27284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27285       };
27286     } catch (std::exception& e) {
27287       {
27288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27289       };
27290     } catch (Dali::DaliException e) {
27291       {
27292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27293       };
27294     } catch (...) {
27295       {
27296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27297       };
27298     }
27299   }
27300
27301 }
27302
27303
27304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27305   void * jresult ;
27306   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27307   Dali::Shader result;
27308
27309   arg1 = (Dali::Renderer *)jarg1;
27310   {
27311     try {
27312       result = ((Dali::Renderer const *)arg1)->GetShader();
27313     } catch (std::out_of_range& e) {
27314       {
27315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27316       };
27317     } catch (std::exception& e) {
27318       {
27319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27320       };
27321     } catch (Dali::DaliException e) {
27322       {
27323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27324       };
27325     } catch (...) {
27326       {
27327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27328       };
27329     }
27330   }
27331
27332   jresult = new Dali::Shader((const Dali::Shader &)result);
27333   return jresult;
27334 }
27335
27336
27337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27338   void * jresult ;
27339   Dali::FrameBuffer::Attachment *result = 0 ;
27340
27341   {
27342     try {
27343       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27344     } catch (std::out_of_range& e) {
27345       {
27346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27347       };
27348     } catch (std::exception& e) {
27349       {
27350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27351       };
27352     } catch (Dali::DaliException e) {
27353       {
27354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27355       };
27356     } catch (...) {
27357       {
27358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27359       };
27360     }
27361   }
27362
27363   jresult = (void *)result;
27364   return jresult;
27365 }
27366
27367
27368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27369   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27370
27371   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27372   {
27373     try {
27374       delete arg1;
27375     } catch (std::out_of_range& e) {
27376       {
27377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27378       };
27379     } catch (std::exception& e) {
27380       {
27381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27382       };
27383     } catch (Dali::DaliException e) {
27384       {
27385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27386       };
27387     } catch (...) {
27388       {
27389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27390       };
27391     }
27392   }
27393
27394 }
27395
27396
27397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27398   void * jresult ;
27399   unsigned int arg1 ;
27400   unsigned int arg2 ;
27401   unsigned int arg3 ;
27402   Dali::FrameBuffer result;
27403
27404   arg1 = (unsigned int)jarg1;
27405   arg2 = (unsigned int)jarg2;
27406   arg3 = (unsigned int)jarg3;
27407   {
27408     try {
27409       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27410     } catch (std::out_of_range& e) {
27411       {
27412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27413       };
27414     } catch (std::exception& e) {
27415       {
27416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27417       };
27418     } catch (Dali::DaliException e) {
27419       {
27420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27421       };
27422     } catch (...) {
27423       {
27424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27425       };
27426     }
27427   }
27428
27429   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27430   return jresult;
27431 }
27432
27433
27434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27435   void * jresult ;
27436   Dali::FrameBuffer *result = 0 ;
27437
27438   {
27439     try {
27440       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27441     } catch (std::out_of_range& e) {
27442       {
27443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27444       };
27445     } catch (std::exception& e) {
27446       {
27447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27448       };
27449     } catch (Dali::DaliException e) {
27450       {
27451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27452       };
27453     } catch (...) {
27454       {
27455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27456       };
27457     }
27458   }
27459
27460   jresult = (void *)result;
27461   return jresult;
27462 }
27463
27464
27465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27466   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27467
27468   arg1 = (Dali::FrameBuffer *)jarg1;
27469   {
27470     try {
27471       delete arg1;
27472     } catch (std::out_of_range& e) {
27473       {
27474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27475       };
27476     } catch (std::exception& e) {
27477       {
27478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27479       };
27480     } catch (Dali::DaliException e) {
27481       {
27482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27483       };
27484     } catch (...) {
27485       {
27486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27487       };
27488     }
27489   }
27490
27491 }
27492
27493
27494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27495   void * jresult ;
27496   Dali::FrameBuffer *arg1 = 0 ;
27497   Dali::FrameBuffer *result = 0 ;
27498
27499   arg1 = (Dali::FrameBuffer *)jarg1;
27500   if (!arg1) {
27501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27502     return 0;
27503   }
27504   {
27505     try {
27506       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27507     } catch (std::out_of_range& e) {
27508       {
27509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27510       };
27511     } catch (std::exception& e) {
27512       {
27513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27514       };
27515     } catch (Dali::DaliException e) {
27516       {
27517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27518       };
27519     } catch (...) {
27520       {
27521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27522       };
27523     }
27524   }
27525
27526   jresult = (void *)result;
27527   return jresult;
27528 }
27529
27530
27531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27532   void * jresult ;
27533   Dali::BaseHandle arg1 ;
27534   Dali::BaseHandle *argp1 ;
27535   Dali::FrameBuffer result;
27536
27537   argp1 = (Dali::BaseHandle *)jarg1;
27538   if (!argp1) {
27539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27540     return 0;
27541   }
27542   arg1 = *argp1;
27543   {
27544     try {
27545       result = Dali::FrameBuffer::DownCast(arg1);
27546     } catch (std::out_of_range& e) {
27547       {
27548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27549       };
27550     } catch (std::exception& e) {
27551       {
27552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27553       };
27554     } catch (Dali::DaliException e) {
27555       {
27556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27557       };
27558     } catch (...) {
27559       {
27560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27561       };
27562     }
27563   }
27564
27565   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27566   return jresult;
27567 }
27568
27569
27570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27571   void * jresult ;
27572   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27573   Dali::FrameBuffer *arg2 = 0 ;
27574   Dali::FrameBuffer *result = 0 ;
27575
27576   arg1 = (Dali::FrameBuffer *)jarg1;
27577   arg2 = (Dali::FrameBuffer *)jarg2;
27578   if (!arg2) {
27579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27580     return 0;
27581   }
27582   {
27583     try {
27584       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27585     } catch (std::out_of_range& e) {
27586       {
27587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27588       };
27589     } catch (std::exception& e) {
27590       {
27591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27592       };
27593     } catch (Dali::DaliException e) {
27594       {
27595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27596       };
27597     } catch (...) {
27598       {
27599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27600       };
27601     }
27602   }
27603
27604   jresult = (void *)result;
27605   return jresult;
27606 }
27607
27608
27609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27610   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27611   Dali::Texture *arg2 = 0 ;
27612
27613   arg1 = (Dali::FrameBuffer *)jarg1;
27614   arg2 = (Dali::Texture *)jarg2;
27615   if (!arg2) {
27616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27617     return ;
27618   }
27619   {
27620     try {
27621       (arg1)->AttachColorTexture(*arg2);
27622     } catch (std::out_of_range& e) {
27623       {
27624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27625       };
27626     } catch (std::exception& e) {
27627       {
27628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27629       };
27630     } catch (Dali::DaliException e) {
27631       {
27632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27633       };
27634     } catch (...) {
27635       {
27636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27637       };
27638     }
27639   }
27640
27641 }
27642
27643
27644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27645   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27646   Dali::Texture *arg2 = 0 ;
27647   unsigned int arg3 ;
27648   unsigned int arg4 ;
27649
27650   arg1 = (Dali::FrameBuffer *)jarg1;
27651   arg2 = (Dali::Texture *)jarg2;
27652   if (!arg2) {
27653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27654     return ;
27655   }
27656   arg3 = (unsigned int)jarg3;
27657   arg4 = (unsigned int)jarg4;
27658   {
27659     try {
27660       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27661     } catch (std::out_of_range& e) {
27662       {
27663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27664       };
27665     } catch (std::exception& e) {
27666       {
27667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27668       };
27669     } catch (Dali::DaliException e) {
27670       {
27671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27672       };
27673     } catch (...) {
27674       {
27675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27676       };
27677     }
27678   }
27679
27680 }
27681
27682
27683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27684   void * jresult ;
27685   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27686   Dali::Texture result;
27687
27688   arg1 = (Dali::FrameBuffer *)jarg1;
27689   {
27690     try {
27691       result = (arg1)->GetColorTexture();
27692     } catch (std::out_of_range& e) {
27693       {
27694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27695       };
27696     } catch (std::exception& e) {
27697       {
27698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27699       };
27700     } catch (Dali::DaliException e) {
27701       {
27702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27703       };
27704     } catch (...) {
27705       {
27706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27707       };
27708     }
27709   }
27710
27711   jresult = new Dali::Texture((const Dali::Texture &)result);
27712   return jresult;
27713 }
27714
27715
27716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27717   void * jresult ;
27718   Dali::RenderTaskList *result = 0 ;
27719
27720   {
27721     try {
27722       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27723     } catch (std::out_of_range& e) {
27724       {
27725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27726       };
27727     } catch (std::exception& e) {
27728       {
27729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27730       };
27731     } catch (Dali::DaliException e) {
27732       {
27733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27734       };
27735     } catch (...) {
27736       {
27737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27738       };
27739     }
27740   }
27741
27742   jresult = (void *)result;
27743   return jresult;
27744 }
27745
27746
27747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27748   void * jresult ;
27749   Dali::BaseHandle arg1 ;
27750   Dali::BaseHandle *argp1 ;
27751   Dali::RenderTaskList result;
27752
27753   argp1 = (Dali::BaseHandle *)jarg1;
27754   if (!argp1) {
27755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27756     return 0;
27757   }
27758   arg1 = *argp1;
27759   {
27760     try {
27761       result = Dali::RenderTaskList::DownCast(arg1);
27762     } catch (std::out_of_range& e) {
27763       {
27764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27765       };
27766     } catch (std::exception& e) {
27767       {
27768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27769       };
27770     } catch (Dali::DaliException e) {
27771       {
27772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27773       };
27774     } catch (...) {
27775       {
27776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27777       };
27778     }
27779   }
27780
27781   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27782   return jresult;
27783 }
27784
27785
27786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27787   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27788
27789   arg1 = (Dali::RenderTaskList *)jarg1;
27790   {
27791     try {
27792       delete arg1;
27793     } catch (std::out_of_range& e) {
27794       {
27795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27796       };
27797     } catch (std::exception& e) {
27798       {
27799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27800       };
27801     } catch (Dali::DaliException e) {
27802       {
27803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27804       };
27805     } catch (...) {
27806       {
27807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27808       };
27809     }
27810   }
27811
27812 }
27813
27814
27815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27816   void * jresult ;
27817   Dali::RenderTaskList *arg1 = 0 ;
27818   Dali::RenderTaskList *result = 0 ;
27819
27820   arg1 = (Dali::RenderTaskList *)jarg1;
27821   if (!arg1) {
27822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27823     return 0;
27824   }
27825   {
27826     try {
27827       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27828     } catch (std::out_of_range& e) {
27829       {
27830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27831       };
27832     } catch (std::exception& e) {
27833       {
27834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27835       };
27836     } catch (Dali::DaliException e) {
27837       {
27838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27839       };
27840     } catch (...) {
27841       {
27842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27843       };
27844     }
27845   }
27846
27847   jresult = (void *)result;
27848   return jresult;
27849 }
27850
27851
27852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27853   void * jresult ;
27854   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27855   Dali::RenderTaskList *arg2 = 0 ;
27856   Dali::RenderTaskList *result = 0 ;
27857
27858   arg1 = (Dali::RenderTaskList *)jarg1;
27859   arg2 = (Dali::RenderTaskList *)jarg2;
27860   if (!arg2) {
27861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27862     return 0;
27863   }
27864   {
27865     try {
27866       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27867     } catch (std::out_of_range& e) {
27868       {
27869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27870       };
27871     } catch (std::exception& e) {
27872       {
27873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27874       };
27875     } catch (Dali::DaliException e) {
27876       {
27877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27878       };
27879     } catch (...) {
27880       {
27881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27882       };
27883     }
27884   }
27885
27886   jresult = (void *)result;
27887   return jresult;
27888 }
27889
27890
27891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27892   void * jresult ;
27893   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27894   Dali::RenderTask result;
27895
27896   arg1 = (Dali::RenderTaskList *)jarg1;
27897   {
27898     try {
27899       result = (arg1)->CreateTask();
27900     } catch (std::out_of_range& e) {
27901       {
27902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27903       };
27904     } catch (std::exception& e) {
27905       {
27906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27907       };
27908     } catch (Dali::DaliException e) {
27909       {
27910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27911       };
27912     } catch (...) {
27913       {
27914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27915       };
27916     }
27917   }
27918
27919   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27920   return jresult;
27921 }
27922
27923
27924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27925   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27926   Dali::RenderTask arg2 ;
27927   Dali::RenderTask *argp2 ;
27928
27929   arg1 = (Dali::RenderTaskList *)jarg1;
27930   argp2 = (Dali::RenderTask *)jarg2;
27931   if (!argp2) {
27932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27933     return ;
27934   }
27935   arg2 = *argp2;
27936   {
27937     try {
27938       (arg1)->RemoveTask(arg2);
27939     } catch (std::out_of_range& e) {
27940       {
27941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27942       };
27943     } catch (std::exception& e) {
27944       {
27945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27946       };
27947     } catch (Dali::DaliException e) {
27948       {
27949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27950       };
27951     } catch (...) {
27952       {
27953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27954       };
27955     }
27956   }
27957
27958 }
27959
27960
27961 //// ===============================================end part 1 =================
27962
27963 //// ========================= part 2 ===============================
27964
27965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27966   unsigned int jresult ;
27967   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27968   unsigned int result;
27969
27970   arg1 = (Dali::RenderTaskList *)jarg1;
27971   {
27972     try {
27973       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27974     } catch (std::out_of_range& e) {
27975       {
27976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27977       };
27978     } catch (std::exception& e) {
27979       {
27980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27981       };
27982     } catch (Dali::DaliException e) {
27983       {
27984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27985       };
27986     } catch (...) {
27987       {
27988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27989       };
27990     }
27991   }
27992
27993   jresult = result;
27994   return jresult;
27995 }
27996
27997
27998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27999   void * jresult ;
28000   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28001   unsigned int arg2 ;
28002   Dali::RenderTask result;
28003
28004   arg1 = (Dali::RenderTaskList *)jarg1;
28005   arg2 = (unsigned int)jarg2;
28006   {
28007     try {
28008       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28009     } catch (std::out_of_range& e) {
28010       {
28011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28012       };
28013     } catch (std::exception& e) {
28014       {
28015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28016       };
28017     } catch (Dali::DaliException e) {
28018       {
28019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28020       };
28021     } catch (...) {
28022       {
28023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28024       };
28025     }
28026   }
28027
28028   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28029   return jresult;
28030 }
28031
28032
28033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28034   int jresult ;
28035   int result;
28036
28037   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28038   jresult = (int)result;
28039   return jresult;
28040 }
28041
28042
28043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28044   int jresult ;
28045   int result;
28046
28047   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28048   jresult = (int)result;
28049   return jresult;
28050 }
28051
28052
28053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28054   int jresult ;
28055   int result;
28056
28057   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28058   jresult = (int)result;
28059   return jresult;
28060 }
28061
28062
28063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28064   int jresult ;
28065   int result;
28066
28067   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28068   jresult = (int)result;
28069   return jresult;
28070 }
28071
28072
28073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28074   void * jresult ;
28075   Dali::RenderTask::Property *result = 0 ;
28076
28077   {
28078     try {
28079       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
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 = (void *)result;
28100   return jresult;
28101 }
28102
28103
28104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28105   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28106
28107   arg1 = (Dali::RenderTask::Property *)jarg1;
28108   {
28109     try {
28110       delete arg1;
28111     } catch (std::out_of_range& e) {
28112       {
28113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28114       };
28115     } catch (std::exception& e) {
28116       {
28117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28118       };
28119     } catch (Dali::DaliException e) {
28120       {
28121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28122       };
28123     } catch (...) {
28124       {
28125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28126       };
28127     }
28128   }
28129
28130 }
28131
28132
28133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28134   void * jresult ;
28135   bool (*result)(Dali::Vector2 &) = 0 ;
28136
28137   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28138   jresult = (void *)result;
28139   return jresult;
28140 }
28141
28142
28143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28144   void * jresult ;
28145   bool (*result)(Dali::Vector2 &) = 0 ;
28146
28147   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28148   jresult = (void *)result;
28149   return jresult;
28150 }
28151
28152
28153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28154   unsigned int jresult ;
28155   bool result;
28156
28157   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28158   jresult = result;
28159   return jresult;
28160 }
28161
28162
28163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28164   unsigned int jresult ;
28165   bool result;
28166
28167   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28168   jresult = result;
28169   return jresult;
28170 }
28171
28172
28173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28174   void * jresult ;
28175   Dali::Vector4 *result = 0 ;
28176
28177   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28178   jresult = (void *)result;
28179   return jresult;
28180 }
28181
28182
28183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28184   unsigned int jresult ;
28185   bool result;
28186
28187   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28188   jresult = result;
28189   return jresult;
28190 }
28191
28192
28193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28194   unsigned int jresult ;
28195   bool result;
28196
28197   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28198   jresult = result;
28199   return jresult;
28200 }
28201
28202
28203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28204   unsigned int jresult ;
28205   unsigned int result;
28206
28207   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28208   jresult = result;
28209   return jresult;
28210 }
28211
28212
28213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28214   void * jresult ;
28215   Dali::RenderTask *result = 0 ;
28216
28217   {
28218     try {
28219       result = (Dali::RenderTask *)new Dali::RenderTask();
28220     } catch (std::out_of_range& e) {
28221       {
28222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28223       };
28224     } catch (std::exception& e) {
28225       {
28226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28227       };
28228     } catch (Dali::DaliException e) {
28229       {
28230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28231       };
28232     } catch (...) {
28233       {
28234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28235       };
28236     }
28237   }
28238
28239   jresult = (void *)result;
28240   return jresult;
28241 }
28242
28243
28244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28245   void * jresult ;
28246   Dali::BaseHandle arg1 ;
28247   Dali::BaseHandle *argp1 ;
28248   Dali::RenderTask result;
28249
28250   argp1 = (Dali::BaseHandle *)jarg1;
28251   if (!argp1) {
28252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28253     return 0;
28254   }
28255   arg1 = *argp1;
28256   {
28257     try {
28258       result = Dali::RenderTask::DownCast(arg1);
28259     } catch (std::out_of_range& e) {
28260       {
28261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28262       };
28263     } catch (std::exception& e) {
28264       {
28265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28266       };
28267     } catch (Dali::DaliException e) {
28268       {
28269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28270       };
28271     } catch (...) {
28272       {
28273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28274       };
28275     }
28276   }
28277
28278   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28279   return jresult;
28280 }
28281
28282
28283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28284   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28285
28286   arg1 = (Dali::RenderTask *)jarg1;
28287   {
28288     try {
28289       delete arg1;
28290     } catch (std::out_of_range& e) {
28291       {
28292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28293       };
28294     } catch (std::exception& e) {
28295       {
28296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28297       };
28298     } catch (Dali::DaliException e) {
28299       {
28300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28301       };
28302     } catch (...) {
28303       {
28304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28305       };
28306     }
28307   }
28308
28309 }
28310
28311
28312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28313   void * jresult ;
28314   Dali::RenderTask *arg1 = 0 ;
28315   Dali::RenderTask *result = 0 ;
28316
28317   arg1 = (Dali::RenderTask *)jarg1;
28318   if (!arg1) {
28319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28320     return 0;
28321   }
28322   {
28323     try {
28324       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28325     } catch (std::out_of_range& e) {
28326       {
28327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28328       };
28329     } catch (std::exception& e) {
28330       {
28331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28332       };
28333     } catch (Dali::DaliException e) {
28334       {
28335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28336       };
28337     } catch (...) {
28338       {
28339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28340       };
28341     }
28342   }
28343
28344   jresult = (void *)result;
28345   return jresult;
28346 }
28347
28348
28349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28350   void * jresult ;
28351   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28352   Dali::RenderTask *arg2 = 0 ;
28353   Dali::RenderTask *result = 0 ;
28354
28355   arg1 = (Dali::RenderTask *)jarg1;
28356   arg2 = (Dali::RenderTask *)jarg2;
28357   if (!arg2) {
28358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28359     return 0;
28360   }
28361   {
28362     try {
28363       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28364     } catch (std::out_of_range& e) {
28365       {
28366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28367       };
28368     } catch (std::exception& e) {
28369       {
28370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28371       };
28372     } catch (Dali::DaliException e) {
28373       {
28374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28375       };
28376     } catch (...) {
28377       {
28378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28379       };
28380     }
28381   }
28382
28383   jresult = (void *)result;
28384   return jresult;
28385 }
28386
28387
28388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28389   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28390   Dali::Actor arg2 ;
28391   Dali::Actor *argp2 ;
28392
28393   arg1 = (Dali::RenderTask *)jarg1;
28394   argp2 = (Dali::Actor *)jarg2;
28395   if (!argp2) {
28396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28397     return ;
28398   }
28399   arg2 = *argp2;
28400   {
28401     try {
28402       (arg1)->SetSourceActor(arg2);
28403     } catch (std::out_of_range& e) {
28404       {
28405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28406       };
28407     } catch (std::exception& e) {
28408       {
28409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28410       };
28411     } catch (Dali::DaliException e) {
28412       {
28413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28414       };
28415     } catch (...) {
28416       {
28417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28418       };
28419     }
28420   }
28421
28422 }
28423
28424
28425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28426   void * jresult ;
28427   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28428   Dali::Actor result;
28429
28430   arg1 = (Dali::RenderTask *)jarg1;
28431   {
28432     try {
28433       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28434     } catch (std::out_of_range& e) {
28435       {
28436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28437       };
28438     } catch (std::exception& e) {
28439       {
28440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28441       };
28442     } catch (Dali::DaliException e) {
28443       {
28444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28445       };
28446     } catch (...) {
28447       {
28448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28449       };
28450     }
28451   }
28452
28453   jresult = new Dali::Actor((const Dali::Actor &)result);
28454   return jresult;
28455 }
28456
28457
28458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28459   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28460   bool arg2 ;
28461
28462   arg1 = (Dali::RenderTask *)jarg1;
28463   arg2 = jarg2 ? true : false;
28464   {
28465     try {
28466       (arg1)->SetExclusive(arg2);
28467     } catch (std::out_of_range& e) {
28468       {
28469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28470       };
28471     } catch (std::exception& e) {
28472       {
28473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28474       };
28475     } catch (Dali::DaliException e) {
28476       {
28477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28478       };
28479     } catch (...) {
28480       {
28481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28482       };
28483     }
28484   }
28485
28486 }
28487
28488
28489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28490   unsigned int jresult ;
28491   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28492   bool result;
28493
28494   arg1 = (Dali::RenderTask *)jarg1;
28495   {
28496     try {
28497       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28498     } catch (std::out_of_range& e) {
28499       {
28500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28501       };
28502     } catch (std::exception& e) {
28503       {
28504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28505       };
28506     } catch (Dali::DaliException e) {
28507       {
28508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28509       };
28510     } catch (...) {
28511       {
28512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28513       };
28514     }
28515   }
28516
28517   jresult = result;
28518   return jresult;
28519 }
28520
28521
28522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28523   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28524   bool arg2 ;
28525
28526   arg1 = (Dali::RenderTask *)jarg1;
28527   arg2 = jarg2 ? true : false;
28528   {
28529     try {
28530       (arg1)->SetInputEnabled(arg2);
28531     } catch (std::out_of_range& e) {
28532       {
28533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28534       };
28535     } catch (std::exception& e) {
28536       {
28537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28538       };
28539     } catch (Dali::DaliException e) {
28540       {
28541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28542       };
28543     } catch (...) {
28544       {
28545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28546       };
28547     }
28548   }
28549
28550 }
28551
28552
28553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28554   unsigned int jresult ;
28555   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28556   bool result;
28557
28558   arg1 = (Dali::RenderTask *)jarg1;
28559   {
28560     try {
28561       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28562     } catch (std::out_of_range& e) {
28563       {
28564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28565       };
28566     } catch (std::exception& e) {
28567       {
28568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28569       };
28570     } catch (Dali::DaliException e) {
28571       {
28572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28573       };
28574     } catch (...) {
28575       {
28576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28577       };
28578     }
28579   }
28580
28581   jresult = result;
28582   return jresult;
28583 }
28584
28585
28586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28587   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28588   Dali::CameraActor arg2 ;
28589   Dali::CameraActor *argp2 ;
28590
28591   arg1 = (Dali::RenderTask *)jarg1;
28592   argp2 = (Dali::CameraActor *)jarg2;
28593   if (!argp2) {
28594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28595     return ;
28596   }
28597   arg2 = *argp2;
28598   {
28599     try {
28600       (arg1)->SetCameraActor(arg2);
28601     } catch (std::out_of_range& e) {
28602       {
28603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28604       };
28605     } catch (std::exception& e) {
28606       {
28607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28608       };
28609     } catch (Dali::DaliException e) {
28610       {
28611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28612       };
28613     } catch (...) {
28614       {
28615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28616       };
28617     }
28618   }
28619
28620 }
28621
28622
28623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28624   void * jresult ;
28625   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28626   Dali::CameraActor result;
28627
28628   arg1 = (Dali::RenderTask *)jarg1;
28629   {
28630     try {
28631       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28632     } catch (std::out_of_range& e) {
28633       {
28634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28635       };
28636     } catch (std::exception& e) {
28637       {
28638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28639       };
28640     } catch (Dali::DaliException e) {
28641       {
28642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28643       };
28644     } catch (...) {
28645       {
28646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28647       };
28648     }
28649   }
28650
28651   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28652   return jresult;
28653 }
28654
28655
28656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28657   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28658   Dali::FrameBufferImage arg2 ;
28659   Dali::FrameBufferImage *argp2 ;
28660
28661   arg1 = (Dali::RenderTask *)jarg1;
28662   argp2 = (Dali::FrameBufferImage *)jarg2;
28663   if (!argp2) {
28664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28665     return ;
28666   }
28667   arg2 = *argp2;
28668   {
28669     try {
28670       (arg1)->SetTargetFrameBuffer(arg2);
28671     } catch (std::out_of_range& e) {
28672       {
28673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28674       };
28675     } catch (std::exception& e) {
28676       {
28677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28678       };
28679     } catch (Dali::DaliException e) {
28680       {
28681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28682       };
28683     } catch (...) {
28684       {
28685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28686       };
28687     }
28688   }
28689
28690 }
28691
28692
28693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28694   void * jresult ;
28695   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28696   Dali::FrameBufferImage result;
28697
28698   arg1 = (Dali::RenderTask *)jarg1;
28699   {
28700     try {
28701       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28702     } catch (std::out_of_range& e) {
28703       {
28704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28705       };
28706     } catch (std::exception& e) {
28707       {
28708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28709       };
28710     } catch (Dali::DaliException e) {
28711       {
28712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28713       };
28714     } catch (...) {
28715       {
28716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28717       };
28718     }
28719   }
28720
28721   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28722   return jresult;
28723 }
28724
28725
28726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28727   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28728   Dali::FrameBuffer arg2 ;
28729   Dali::FrameBuffer *argp2 ;
28730
28731   arg1 = (Dali::RenderTask *)jarg1;
28732   argp2 = (Dali::FrameBuffer *)jarg2;
28733   if (!argp2) {
28734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28735     return ;
28736   }
28737   arg2 = *argp2;
28738   {
28739     try {
28740       (arg1)->SetFrameBuffer(arg2);
28741     } catch (std::out_of_range& e) {
28742       {
28743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28744       };
28745     } catch (std::exception& e) {
28746       {
28747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28748       };
28749     } catch (Dali::DaliException e) {
28750       {
28751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28752       };
28753     } catch (...) {
28754       {
28755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28756       };
28757     }
28758   }
28759
28760 }
28761
28762
28763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28764   void * jresult ;
28765   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28766   Dali::FrameBuffer result;
28767
28768   arg1 = (Dali::RenderTask *)jarg1;
28769   {
28770     try {
28771       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28772     } catch (std::out_of_range& e) {
28773       {
28774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28775       };
28776     } catch (std::exception& e) {
28777       {
28778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28779       };
28780     } catch (Dali::DaliException e) {
28781       {
28782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28783       };
28784     } catch (...) {
28785       {
28786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28787       };
28788     }
28789   }
28790
28791   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28792   return jresult;
28793 }
28794
28795
28796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28797   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28798   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28799
28800   arg1 = (Dali::RenderTask *)jarg1;
28801   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28802   {
28803     try {
28804       (arg1)->SetScreenToFrameBufferFunction(arg2);
28805     } catch (std::out_of_range& e) {
28806       {
28807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28808       };
28809     } catch (std::exception& e) {
28810       {
28811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28812       };
28813     } catch (Dali::DaliException e) {
28814       {
28815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28816       };
28817     } catch (...) {
28818       {
28819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28820       };
28821     }
28822   }
28823
28824 }
28825
28826
28827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28828   void * jresult ;
28829   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28830   Dali::RenderTask::ScreenToFrameBufferFunction result;
28831
28832   arg1 = (Dali::RenderTask *)jarg1;
28833   {
28834     try {
28835       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28836     } catch (std::out_of_range& e) {
28837       {
28838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28839       };
28840     } catch (std::exception& e) {
28841       {
28842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28843       };
28844     } catch (Dali::DaliException e) {
28845       {
28846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28847       };
28848     } catch (...) {
28849       {
28850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28851       };
28852     }
28853   }
28854
28855   jresult = (void *)result;
28856   return jresult;
28857 }
28858
28859
28860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28861   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28862   Dali::Actor arg2 ;
28863   Dali::Actor *argp2 ;
28864
28865   arg1 = (Dali::RenderTask *)jarg1;
28866   argp2 = (Dali::Actor *)jarg2;
28867   if (!argp2) {
28868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28869     return ;
28870   }
28871   arg2 = *argp2;
28872   {
28873     try {
28874       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28875     } catch (std::out_of_range& e) {
28876       {
28877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28878       };
28879     } catch (std::exception& e) {
28880       {
28881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28882       };
28883     } catch (Dali::DaliException e) {
28884       {
28885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28886       };
28887     } catch (...) {
28888       {
28889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28890       };
28891     }
28892   }
28893
28894 }
28895
28896
28897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28898   void * jresult ;
28899   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28900   Dali::Actor result;
28901
28902   arg1 = (Dali::RenderTask *)jarg1;
28903   {
28904     try {
28905       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28906     } catch (std::out_of_range& e) {
28907       {
28908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28909       };
28910     } catch (std::exception& e) {
28911       {
28912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28913       };
28914     } catch (Dali::DaliException e) {
28915       {
28916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28917       };
28918     } catch (...) {
28919       {
28920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28921       };
28922     }
28923   }
28924
28925   jresult = new Dali::Actor((const Dali::Actor &)result);
28926   return jresult;
28927 }
28928
28929
28930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28931   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28932   Dali::Vector2 arg2 ;
28933   Dali::Vector2 *argp2 ;
28934
28935   arg1 = (Dali::RenderTask *)jarg1;
28936   argp2 = (Dali::Vector2 *)jarg2;
28937   if (!argp2) {
28938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28939     return ;
28940   }
28941   arg2 = *argp2;
28942   {
28943     try {
28944       (arg1)->SetViewportPosition(arg2);
28945     } catch (std::out_of_range& e) {
28946       {
28947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28948       };
28949     } catch (std::exception& e) {
28950       {
28951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28952       };
28953     } catch (Dali::DaliException e) {
28954       {
28955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28956       };
28957     } catch (...) {
28958       {
28959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28960       };
28961     }
28962   }
28963
28964 }
28965
28966
28967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28968   void * jresult ;
28969   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28970   Dali::Vector2 result;
28971
28972   arg1 = (Dali::RenderTask *)jarg1;
28973   {
28974     try {
28975       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28976     } catch (std::out_of_range& e) {
28977       {
28978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28979       };
28980     } catch (std::exception& e) {
28981       {
28982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28983       };
28984     } catch (Dali::DaliException e) {
28985       {
28986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28987       };
28988     } catch (...) {
28989       {
28990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28991       };
28992     }
28993   }
28994
28995   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28996   return jresult;
28997 }
28998
28999
29000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29001   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29002   Dali::Vector2 arg2 ;
29003   Dali::Vector2 *argp2 ;
29004
29005   arg1 = (Dali::RenderTask *)jarg1;
29006   argp2 = (Dali::Vector2 *)jarg2;
29007   if (!argp2) {
29008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29009     return ;
29010   }
29011   arg2 = *argp2;
29012   {
29013     try {
29014       (arg1)->SetViewportSize(arg2);
29015     } catch (std::out_of_range& e) {
29016       {
29017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29018       };
29019     } catch (std::exception& e) {
29020       {
29021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29022       };
29023     } catch (Dali::DaliException e) {
29024       {
29025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29026       };
29027     } catch (...) {
29028       {
29029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29030       };
29031     }
29032   }
29033
29034 }
29035
29036
29037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29038   void * jresult ;
29039   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29040   Dali::Vector2 result;
29041
29042   arg1 = (Dali::RenderTask *)jarg1;
29043   {
29044     try {
29045       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29046     } catch (std::out_of_range& e) {
29047       {
29048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29049       };
29050     } catch (std::exception& e) {
29051       {
29052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29053       };
29054     } catch (Dali::DaliException e) {
29055       {
29056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29057       };
29058     } catch (...) {
29059       {
29060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29061       };
29062     }
29063   }
29064
29065   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29066   return jresult;
29067 }
29068
29069
29070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29071   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29072   Dali::Viewport arg2 ;
29073   Dali::Viewport *argp2 ;
29074
29075   arg1 = (Dali::RenderTask *)jarg1;
29076   argp2 = (Dali::Viewport *)jarg2;
29077   if (!argp2) {
29078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29079     return ;
29080   }
29081   arg2 = *argp2;
29082   {
29083     try {
29084       (arg1)->SetViewport(arg2);
29085     } catch (std::out_of_range& e) {
29086       {
29087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29088       };
29089     } catch (std::exception& e) {
29090       {
29091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29092       };
29093     } catch (Dali::DaliException e) {
29094       {
29095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29096       };
29097     } catch (...) {
29098       {
29099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29100       };
29101     }
29102   }
29103
29104 }
29105
29106
29107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29108   void * jresult ;
29109   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29110   Dali::Viewport result;
29111
29112   arg1 = (Dali::RenderTask *)jarg1;
29113   {
29114     try {
29115       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29116     } catch (std::out_of_range& e) {
29117       {
29118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29119       };
29120     } catch (std::exception& e) {
29121       {
29122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29123       };
29124     } catch (Dali::DaliException e) {
29125       {
29126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29127       };
29128     } catch (...) {
29129       {
29130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29131       };
29132     }
29133   }
29134
29135   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29136   return jresult;
29137 }
29138
29139
29140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29141   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29142   Dali::Vector4 *arg2 = 0 ;
29143
29144   arg1 = (Dali::RenderTask *)jarg1;
29145   arg2 = (Dali::Vector4 *)jarg2;
29146   if (!arg2) {
29147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29148     return ;
29149   }
29150   {
29151     try {
29152       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29153     } catch (std::out_of_range& e) {
29154       {
29155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29156       };
29157     } catch (std::exception& e) {
29158       {
29159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29160       };
29161     } catch (Dali::DaliException e) {
29162       {
29163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29164       };
29165     } catch (...) {
29166       {
29167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29168       };
29169     }
29170   }
29171
29172 }
29173
29174
29175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29176   void * jresult ;
29177   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29178   Dali::Vector4 result;
29179
29180   arg1 = (Dali::RenderTask *)jarg1;
29181   {
29182     try {
29183       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29184     } catch (std::out_of_range& e) {
29185       {
29186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29187       };
29188     } catch (std::exception& e) {
29189       {
29190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29191       };
29192     } catch (Dali::DaliException e) {
29193       {
29194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29195       };
29196     } catch (...) {
29197       {
29198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29199       };
29200     }
29201   }
29202
29203   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29204   return jresult;
29205 }
29206
29207
29208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29209   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29210   bool arg2 ;
29211
29212   arg1 = (Dali::RenderTask *)jarg1;
29213   arg2 = jarg2 ? true : false;
29214   {
29215     try {
29216       (arg1)->SetClearEnabled(arg2);
29217     } catch (std::out_of_range& e) {
29218       {
29219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29220       };
29221     } catch (std::exception& e) {
29222       {
29223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29224       };
29225     } catch (Dali::DaliException e) {
29226       {
29227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29228       };
29229     } catch (...) {
29230       {
29231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29232       };
29233     }
29234   }
29235
29236 }
29237
29238
29239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29240   unsigned int jresult ;
29241   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29242   bool result;
29243
29244   arg1 = (Dali::RenderTask *)jarg1;
29245   {
29246     try {
29247       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29248     } catch (std::out_of_range& e) {
29249       {
29250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29251       };
29252     } catch (std::exception& e) {
29253       {
29254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29255       };
29256     } catch (Dali::DaliException e) {
29257       {
29258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29259       };
29260     } catch (...) {
29261       {
29262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29263       };
29264     }
29265   }
29266
29267   jresult = result;
29268   return jresult;
29269 }
29270
29271
29272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29273   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29274   bool arg2 ;
29275
29276   arg1 = (Dali::RenderTask *)jarg1;
29277   arg2 = jarg2 ? true : false;
29278   {
29279     try {
29280       (arg1)->SetCullMode(arg2);
29281     } catch (std::out_of_range& e) {
29282       {
29283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29284       };
29285     } catch (std::exception& e) {
29286       {
29287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29288       };
29289     } catch (Dali::DaliException e) {
29290       {
29291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29292       };
29293     } catch (...) {
29294       {
29295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29296       };
29297     }
29298   }
29299
29300 }
29301
29302
29303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29304   unsigned int jresult ;
29305   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29306   bool result;
29307
29308   arg1 = (Dali::RenderTask *)jarg1;
29309   {
29310     try {
29311       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29312     } catch (std::out_of_range& e) {
29313       {
29314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29315       };
29316     } catch (std::exception& e) {
29317       {
29318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29319       };
29320     } catch (Dali::DaliException e) {
29321       {
29322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29323       };
29324     } catch (...) {
29325       {
29326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29327       };
29328     }
29329   }
29330
29331   jresult = result;
29332   return jresult;
29333 }
29334
29335
29336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29337   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29338   unsigned int arg2 ;
29339
29340   arg1 = (Dali::RenderTask *)jarg1;
29341   arg2 = (unsigned int)jarg2;
29342   {
29343     try {
29344       (arg1)->SetRefreshRate(arg2);
29345     } catch (std::out_of_range& e) {
29346       {
29347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29348       };
29349     } catch (std::exception& e) {
29350       {
29351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29352       };
29353     } catch (Dali::DaliException e) {
29354       {
29355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29356       };
29357     } catch (...) {
29358       {
29359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29360       };
29361     }
29362   }
29363
29364 }
29365
29366
29367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29368   unsigned int jresult ;
29369   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29370   unsigned int result;
29371
29372   arg1 = (Dali::RenderTask *)jarg1;
29373   {
29374     try {
29375       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29376     } catch (std::out_of_range& e) {
29377       {
29378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29379       };
29380     } catch (std::exception& e) {
29381       {
29382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29383       };
29384     } catch (Dali::DaliException e) {
29385       {
29386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29387       };
29388     } catch (...) {
29389       {
29390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29391       };
29392     }
29393   }
29394
29395   jresult = result;
29396   return jresult;
29397 }
29398
29399
29400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29401   unsigned int jresult ;
29402   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29403   Dali::Vector3 *arg2 = 0 ;
29404   float *arg3 = 0 ;
29405   float *arg4 = 0 ;
29406   bool result;
29407
29408   arg1 = (Dali::RenderTask *)jarg1;
29409   arg2 = (Dali::Vector3 *)jarg2;
29410   if (!arg2) {
29411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29412     return 0;
29413   }
29414   arg3 = (float *)jarg3;
29415   arg4 = (float *)jarg4;
29416   {
29417     try {
29418       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29419     } catch (std::out_of_range& e) {
29420       {
29421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29422       };
29423     } catch (std::exception& e) {
29424       {
29425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29426       };
29427     } catch (Dali::DaliException e) {
29428       {
29429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29430       };
29431     } catch (...) {
29432       {
29433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29434       };
29435     }
29436   }
29437
29438   jresult = result;
29439   return jresult;
29440 }
29441
29442
29443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29444   unsigned int jresult ;
29445   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29446   Dali::Actor arg2 ;
29447   float arg3 ;
29448   float arg4 ;
29449   float *arg5 = 0 ;
29450   float *arg6 = 0 ;
29451   Dali::Actor *argp2 ;
29452   bool result;
29453
29454   arg1 = (Dali::RenderTask *)jarg1;
29455   argp2 = (Dali::Actor *)jarg2;
29456   if (!argp2) {
29457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29458     return 0;
29459   }
29460   arg2 = *argp2;
29461   arg3 = (float)jarg3;
29462   arg4 = (float)jarg4;
29463   arg5 = (float *)jarg5;
29464   arg6 = (float *)jarg6;
29465   {
29466     try {
29467       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29468     } catch (std::out_of_range& e) {
29469       {
29470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29471       };
29472     } catch (std::exception& e) {
29473       {
29474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29475       };
29476     } catch (Dali::DaliException e) {
29477       {
29478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29479       };
29480     } catch (...) {
29481       {
29482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29483       };
29484     }
29485   }
29486
29487   jresult = result;
29488   return jresult;
29489 }
29490
29491
29492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29493   void * jresult ;
29494   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29495   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29496
29497   arg1 = (Dali::RenderTask *)jarg1;
29498   {
29499     try {
29500       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29501     } catch (std::out_of_range& e) {
29502       {
29503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29504       };
29505     } catch (std::exception& e) {
29506       {
29507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29508       };
29509     } catch (Dali::DaliException e) {
29510       {
29511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29512       };
29513     } catch (...) {
29514       {
29515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29516       };
29517     }
29518   }
29519
29520   jresult = (void *)result;
29521   return jresult;
29522 }
29523
29524
29525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29526   void * jresult ;
29527   int arg1 ;
29528   Dali::TouchPoint::State arg2 ;
29529   float arg3 ;
29530   float arg4 ;
29531   Dali::TouchPoint *result = 0 ;
29532
29533   arg1 = (int)jarg1;
29534   arg2 = (Dali::TouchPoint::State)jarg2;
29535   arg3 = (float)jarg3;
29536   arg4 = (float)jarg4;
29537   {
29538     try {
29539       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29540     } catch (std::out_of_range& e) {
29541       {
29542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29543       };
29544     } catch (std::exception& e) {
29545       {
29546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29547       };
29548     } catch (Dali::DaliException e) {
29549       {
29550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29551       };
29552     } catch (...) {
29553       {
29554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29555       };
29556     }
29557   }
29558
29559   jresult = (void *)result;
29560   return jresult;
29561 }
29562
29563
29564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29565   void * jresult ;
29566   int arg1 ;
29567   Dali::TouchPoint::State arg2 ;
29568   float arg3 ;
29569   float arg4 ;
29570   float arg5 ;
29571   float arg6 ;
29572   Dali::TouchPoint *result = 0 ;
29573
29574   arg1 = (int)jarg1;
29575   arg2 = (Dali::TouchPoint::State)jarg2;
29576   arg3 = (float)jarg3;
29577   arg4 = (float)jarg4;
29578   arg5 = (float)jarg5;
29579   arg6 = (float)jarg6;
29580   {
29581     try {
29582       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29583     } catch (std::out_of_range& e) {
29584       {
29585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29586       };
29587     } catch (std::exception& e) {
29588       {
29589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29590       };
29591     } catch (Dali::DaliException e) {
29592       {
29593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29594       };
29595     } catch (...) {
29596       {
29597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29598       };
29599     }
29600   }
29601
29602   jresult = (void *)result;
29603   return jresult;
29604 }
29605
29606
29607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29608   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29609
29610   arg1 = (Dali::TouchPoint *)jarg1;
29611   {
29612     try {
29613       delete arg1;
29614     } catch (std::out_of_range& e) {
29615       {
29616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29617       };
29618     } catch (std::exception& e) {
29619       {
29620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29621       };
29622     } catch (Dali::DaliException e) {
29623       {
29624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29625       };
29626     } catch (...) {
29627       {
29628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29629       };
29630     }
29631   }
29632
29633 }
29634
29635
29636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29637   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29638   int arg2 ;
29639
29640   arg1 = (Dali::TouchPoint *)jarg1;
29641   arg2 = (int)jarg2;
29642   if (arg1) (arg1)->deviceId = arg2;
29643 }
29644
29645
29646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29647   int jresult ;
29648   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29649   int result;
29650
29651   arg1 = (Dali::TouchPoint *)jarg1;
29652   result = (int) ((arg1)->deviceId);
29653   jresult = result;
29654   return jresult;
29655 }
29656
29657
29658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29659   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29660   Dali::TouchPoint::State arg2 ;
29661
29662   arg1 = (Dali::TouchPoint *)jarg1;
29663   arg2 = (Dali::TouchPoint::State)jarg2;
29664   if (arg1) (arg1)->state = arg2;
29665 }
29666
29667
29668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29669   int jresult ;
29670   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29671   Dali::TouchPoint::State result;
29672
29673   arg1 = (Dali::TouchPoint *)jarg1;
29674   result = (Dali::TouchPoint::State) ((arg1)->state);
29675   jresult = (int)result;
29676   return jresult;
29677 }
29678
29679
29680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29681   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29682   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29683
29684   arg1 = (Dali::TouchPoint *)jarg1;
29685   arg2 = (Dali::Actor *)jarg2;
29686   if (arg1) (arg1)->hitActor = *arg2;
29687 }
29688
29689
29690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29691   void * jresult ;
29692   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29693   Dali::Actor *result = 0 ;
29694
29695   arg1 = (Dali::TouchPoint *)jarg1;
29696   result = (Dali::Actor *)& ((arg1)->hitActor);
29697   jresult = (void *)result;
29698   return jresult;
29699 }
29700
29701
29702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29703   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29704   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29705
29706   arg1 = (Dali::TouchPoint *)jarg1;
29707   arg2 = (Dali::Vector2 *)jarg2;
29708   if (arg1) (arg1)->local = *arg2;
29709 }
29710
29711
29712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29713   void * jresult ;
29714   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29715   Dali::Vector2 *result = 0 ;
29716
29717   arg1 = (Dali::TouchPoint *)jarg1;
29718   result = (Dali::Vector2 *)& ((arg1)->local);
29719   jresult = (void *)result;
29720   return jresult;
29721 }
29722
29723
29724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29725   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29726   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29727
29728   arg1 = (Dali::TouchPoint *)jarg1;
29729   arg2 = (Dali::Vector2 *)jarg2;
29730   if (arg1) (arg1)->screen = *arg2;
29731 }
29732
29733
29734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29735   void * jresult ;
29736   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29737   Dali::Vector2 *result = 0 ;
29738
29739   arg1 = (Dali::TouchPoint *)jarg1;
29740   result = (Dali::Vector2 *)& ((arg1)->screen);
29741   jresult = (void *)result;
29742   return jresult;
29743 }
29744
29745
29746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29747   void * jresult ;
29748   Dali::TouchData *result = 0 ;
29749
29750   {
29751     try {
29752       result = (Dali::TouchData *)new Dali::TouchData();
29753     } catch (std::out_of_range& e) {
29754       {
29755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29756       };
29757     } catch (std::exception& e) {
29758       {
29759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29760       };
29761     } catch (Dali::DaliException e) {
29762       {
29763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29764       };
29765     } catch (...) {
29766       {
29767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29768       };
29769     }
29770   }
29771
29772   jresult = (void *)result;
29773   return jresult;
29774 }
29775
29776
29777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29778   void * jresult ;
29779   Dali::TouchData *arg1 = 0 ;
29780   Dali::TouchData *result = 0 ;
29781
29782   arg1 = (Dali::TouchData *)jarg1;
29783   if (!arg1) {
29784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29785     return 0;
29786   }
29787   {
29788     try {
29789       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29790     } catch (std::out_of_range& e) {
29791       {
29792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29793       };
29794     } catch (std::exception& e) {
29795       {
29796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29797       };
29798     } catch (Dali::DaliException e) {
29799       {
29800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29801       };
29802     } catch (...) {
29803       {
29804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29805       };
29806     }
29807   }
29808
29809   jresult = (void *)result;
29810   return jresult;
29811 }
29812
29813
29814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29815   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29816
29817   arg1 = (Dali::TouchData *)jarg1;
29818   {
29819     try {
29820       delete arg1;
29821     } catch (std::out_of_range& e) {
29822       {
29823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29824       };
29825     } catch (std::exception& e) {
29826       {
29827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29828       };
29829     } catch (Dali::DaliException e) {
29830       {
29831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29832       };
29833     } catch (...) {
29834       {
29835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29836       };
29837     }
29838   }
29839
29840 }
29841
29842
29843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29844   void * jresult ;
29845   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29846   Dali::TouchData *arg2 = 0 ;
29847   Dali::TouchData *result = 0 ;
29848
29849   arg1 = (Dali::TouchData *)jarg1;
29850   arg2 = (Dali::TouchData *)jarg2;
29851   if (!arg2) {
29852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29853     return 0;
29854   }
29855   {
29856     try {
29857       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29858     } catch (std::out_of_range& e) {
29859       {
29860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29861       };
29862     } catch (std::exception& e) {
29863       {
29864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29865       };
29866     } catch (Dali::DaliException e) {
29867       {
29868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29869       };
29870     } catch (...) {
29871       {
29872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29873       };
29874     }
29875   }
29876
29877   jresult = (void *)result;
29878   return jresult;
29879 }
29880
29881
29882 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29883   unsigned long jresult ;
29884   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29885   unsigned long result;
29886
29887   arg1 = (Dali::TouchData *)jarg1;
29888   {
29889     try {
29890       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29891     } catch (std::out_of_range& e) {
29892       {
29893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29894       };
29895     } catch (std::exception& e) {
29896       {
29897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29898       };
29899     } catch (Dali::DaliException e) {
29900       {
29901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29902       };
29903     } catch (...) {
29904       {
29905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29906       };
29907     }
29908   }
29909
29910   jresult = (unsigned long)result;
29911   return jresult;
29912 }
29913
29914
29915 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29916   unsigned long jresult ;
29917   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29918   std::size_t result;
29919
29920   arg1 = (Dali::TouchData *)jarg1;
29921   {
29922     try {
29923       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29924     } catch (std::out_of_range& e) {
29925       {
29926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29927       };
29928     } catch (std::exception& e) {
29929       {
29930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29931       };
29932     } catch (Dali::DaliException e) {
29933       {
29934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29935       };
29936     } catch (...) {
29937       {
29938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29939       };
29940     }
29941   }
29942
29943   jresult = (unsigned long)result;
29944   return jresult;
29945 }
29946
29947
29948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29949   int jresult ;
29950   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29951   std::size_t arg2 ;
29952   int32_t result;
29953
29954   arg1 = (Dali::TouchData *)jarg1;
29955   arg2 = (std::size_t)jarg2;
29956   {
29957     try {
29958       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29959     } catch (std::out_of_range& e) {
29960       {
29961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29962       };
29963     } catch (std::exception& e) {
29964       {
29965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29966       };
29967     } catch (Dali::DaliException e) {
29968       {
29969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29970       };
29971     } catch (...) {
29972       {
29973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29974       };
29975     }
29976   }
29977
29978   jresult = result;
29979   return jresult;
29980 }
29981
29982
29983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29984   int jresult ;
29985   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29986   std::size_t arg2 ;
29987   Dali::PointState::Type result;
29988
29989   arg1 = (Dali::TouchData *)jarg1;
29990   arg2 = (std::size_t)jarg2;
29991   {
29992     try {
29993       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29994     } catch (std::out_of_range& e) {
29995       {
29996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29997       };
29998     } catch (std::exception& e) {
29999       {
30000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30001       };
30002     } catch (Dali::DaliException e) {
30003       {
30004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30005       };
30006     } catch (...) {
30007       {
30008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30009       };
30010     }
30011   }
30012
30013   jresult = (int)result;
30014   return jresult;
30015 }
30016
30017
30018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30019   void * jresult ;
30020   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30021   std::size_t arg2 ;
30022   Dali::Actor result;
30023
30024   arg1 = (Dali::TouchData *)jarg1;
30025   arg2 = (std::size_t)jarg2;
30026   {
30027     try {
30028       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30029     } catch (std::out_of_range& e) {
30030       {
30031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30032       };
30033     } catch (std::exception& e) {
30034       {
30035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30036       };
30037     } catch (Dali::DaliException e) {
30038       {
30039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30040       };
30041     } catch (...) {
30042       {
30043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30044       };
30045     }
30046   }
30047
30048   jresult = new Dali::Actor((const Dali::Actor &)result);
30049   return jresult;
30050 }
30051
30052
30053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30054   void * jresult ;
30055   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30056   std::size_t arg2 ;
30057   Dali::Vector2 *result = 0 ;
30058
30059   arg1 = (Dali::TouchData *)jarg1;
30060   arg2 = (std::size_t)jarg2;
30061   {
30062     try {
30063       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30064     } catch (std::out_of_range& e) {
30065       {
30066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30067       };
30068     } catch (std::exception& e) {
30069       {
30070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30071       };
30072     } catch (Dali::DaliException e) {
30073       {
30074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30075       };
30076     } catch (...) {
30077       {
30078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30079       };
30080     }
30081   }
30082
30083   jresult = (void *)result;
30084   return jresult;
30085 }
30086
30087
30088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30089   void * jresult ;
30090   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30091   std::size_t arg2 ;
30092   Dali::Vector2 *result = 0 ;
30093
30094   arg1 = (Dali::TouchData *)jarg1;
30095   arg2 = (std::size_t)jarg2;
30096   {
30097     try {
30098       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30099     } catch (std::out_of_range& e) {
30100       {
30101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30102       };
30103     } catch (std::exception& e) {
30104       {
30105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30106       };
30107     } catch (Dali::DaliException e) {
30108       {
30109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30110       };
30111     } catch (...) {
30112       {
30113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30114       };
30115     }
30116   }
30117
30118   jresult = (void *)result;
30119   return jresult;
30120 }
30121
30122
30123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30124   float jresult ;
30125   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30126   std::size_t arg2 ;
30127   float result;
30128
30129   arg1 = (Dali::TouchData *)jarg1;
30130   arg2 = (std::size_t)jarg2;
30131   {
30132     try {
30133       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30134     } catch (std::out_of_range& e) {
30135       {
30136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30137       };
30138     } catch (std::exception& e) {
30139       {
30140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30141       };
30142     } catch (Dali::DaliException e) {
30143       {
30144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30145       };
30146     } catch (...) {
30147       {
30148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30149       };
30150     }
30151   }
30152
30153   jresult = result;
30154   return jresult;
30155 }
30156
30157
30158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30159   void * jresult ;
30160   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30161   std::size_t arg2 ;
30162   Dali::Vector2 *result = 0 ;
30163
30164   arg1 = (Dali::TouchData *)jarg1;
30165   arg2 = (std::size_t)jarg2;
30166   {
30167     try {
30168       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30169     } catch (std::out_of_range& e) {
30170       {
30171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30172       };
30173     } catch (std::exception& e) {
30174       {
30175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30176       };
30177     } catch (Dali::DaliException e) {
30178       {
30179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30180       };
30181     } catch (...) {
30182       {
30183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30184       };
30185     }
30186   }
30187
30188   jresult = (void *)result;
30189   return jresult;
30190 }
30191
30192
30193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30194   float jresult ;
30195   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30196   std::size_t arg2 ;
30197   float result;
30198
30199   arg1 = (Dali::TouchData *)jarg1;
30200   arg2 = (std::size_t)jarg2;
30201   {
30202     try {
30203       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30204     } catch (std::out_of_range& e) {
30205       {
30206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30207       };
30208     } catch (std::exception& e) {
30209       {
30210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30211       };
30212     } catch (Dali::DaliException e) {
30213       {
30214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30215       };
30216     } catch (...) {
30217       {
30218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30219       };
30220     }
30221   }
30222
30223   jresult = result;
30224   return jresult;
30225 }
30226
30227
30228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30229   void * jresult ;
30230   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30231   std::size_t arg2 ;
30232   Dali::Degree result;
30233
30234   arg1 = (Dali::TouchData *)jarg1;
30235   arg2 = (std::size_t)jarg2;
30236   {
30237     try {
30238       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30239     } catch (std::out_of_range& e) {
30240       {
30241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30242       };
30243     } catch (std::exception& e) {
30244       {
30245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30246       };
30247     } catch (Dali::DaliException e) {
30248       {
30249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30250       };
30251     } catch (...) {
30252       {
30253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30254       };
30255     }
30256   }
30257
30258   jresult = new Dali::Degree((const Dali::Degree &)result);
30259   return jresult;
30260 }
30261
30262
30263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30264   int jresult ;
30265   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30266   std::size_t arg2 ;
30267   Dali::MouseButton::Type result;
30268
30269   arg1 = (Dali::TouchData *)jarg1;
30270   arg2 = (std::size_t)jarg2;
30271   {
30272     try {
30273       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30274     } catch (std::out_of_range& e) {
30275       {
30276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30277       };
30278     } catch (std::exception& e) {
30279       {
30280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30281       };
30282     } catch (Dali::DaliException e) {
30283       {
30284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30285       };
30286     } catch (...) {
30287       {
30288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30289       };
30290     }
30291   }
30292
30293   jresult = static_cast< int >(result);
30294   return jresult;
30295 }
30296
30297
30298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30299   void * jresult ;
30300   Dali::GestureDetector *result = 0 ;
30301
30302   {
30303     try {
30304       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30305     } catch (std::out_of_range& e) {
30306       {
30307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30308       };
30309     } catch (std::exception& e) {
30310       {
30311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30312       };
30313     } catch (Dali::DaliException e) {
30314       {
30315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30316       };
30317     } catch (...) {
30318       {
30319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30320       };
30321     }
30322   }
30323
30324   jresult = (void *)result;
30325   return jresult;
30326 }
30327
30328
30329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30330   void * jresult ;
30331   Dali::BaseHandle arg1 ;
30332   Dali::BaseHandle *argp1 ;
30333   Dali::GestureDetector result;
30334
30335   argp1 = (Dali::BaseHandle *)jarg1;
30336   if (!argp1) {
30337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30338     return 0;
30339   }
30340   arg1 = *argp1;
30341   {
30342     try {
30343       result = Dali::GestureDetector::DownCast(arg1);
30344     } catch (std::out_of_range& e) {
30345       {
30346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30347       };
30348     } catch (std::exception& e) {
30349       {
30350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30351       };
30352     } catch (Dali::DaliException e) {
30353       {
30354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30355       };
30356     } catch (...) {
30357       {
30358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30359       };
30360     }
30361   }
30362
30363   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30364   return jresult;
30365 }
30366
30367
30368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30369   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30370
30371   arg1 = (Dali::GestureDetector *)jarg1;
30372   {
30373     try {
30374       delete arg1;
30375     } catch (std::out_of_range& e) {
30376       {
30377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30378       };
30379     } catch (std::exception& e) {
30380       {
30381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30382       };
30383     } catch (Dali::DaliException e) {
30384       {
30385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30386       };
30387     } catch (...) {
30388       {
30389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30390       };
30391     }
30392   }
30393
30394 }
30395
30396
30397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30398   void * jresult ;
30399   Dali::GestureDetector *arg1 = 0 ;
30400   Dali::GestureDetector *result = 0 ;
30401
30402   arg1 = (Dali::GestureDetector *)jarg1;
30403   if (!arg1) {
30404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30405     return 0;
30406   }
30407   {
30408     try {
30409       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30410     } catch (std::out_of_range& e) {
30411       {
30412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30413       };
30414     } catch (std::exception& e) {
30415       {
30416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30417       };
30418     } catch (Dali::DaliException e) {
30419       {
30420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30421       };
30422     } catch (...) {
30423       {
30424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30425       };
30426     }
30427   }
30428
30429   jresult = (void *)result;
30430   return jresult;
30431 }
30432
30433
30434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30435   void * jresult ;
30436   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30437   Dali::GestureDetector *arg2 = 0 ;
30438   Dali::GestureDetector *result = 0 ;
30439
30440   arg1 = (Dali::GestureDetector *)jarg1;
30441   arg2 = (Dali::GestureDetector *)jarg2;
30442   if (!arg2) {
30443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30444     return 0;
30445   }
30446   {
30447     try {
30448       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30449     } catch (std::out_of_range& e) {
30450       {
30451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30452       };
30453     } catch (std::exception& e) {
30454       {
30455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30456       };
30457     } catch (Dali::DaliException e) {
30458       {
30459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30460       };
30461     } catch (...) {
30462       {
30463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30464       };
30465     }
30466   }
30467
30468   jresult = (void *)result;
30469   return jresult;
30470 }
30471
30472
30473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30474   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30475   Dali::Actor arg2 ;
30476   Dali::Actor *argp2 ;
30477
30478   arg1 = (Dali::GestureDetector *)jarg1;
30479   argp2 = (Dali::Actor *)jarg2;
30480   if (!argp2) {
30481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30482     return ;
30483   }
30484   arg2 = *argp2;
30485   {
30486     try {
30487       (arg1)->Attach(arg2);
30488     } catch (std::out_of_range& e) {
30489       {
30490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30491       };
30492     } catch (std::exception& e) {
30493       {
30494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30495       };
30496     } catch (Dali::DaliException e) {
30497       {
30498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30499       };
30500     } catch (...) {
30501       {
30502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30503       };
30504     }
30505   }
30506
30507 }
30508
30509
30510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30511   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30512   Dali::Actor arg2 ;
30513   Dali::Actor *argp2 ;
30514
30515   arg1 = (Dali::GestureDetector *)jarg1;
30516   argp2 = (Dali::Actor *)jarg2;
30517   if (!argp2) {
30518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30519     return ;
30520   }
30521   arg2 = *argp2;
30522   {
30523     try {
30524       (arg1)->Detach(arg2);
30525     } catch (std::out_of_range& e) {
30526       {
30527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30528       };
30529     } catch (std::exception& e) {
30530       {
30531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30532       };
30533     } catch (Dali::DaliException e) {
30534       {
30535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30536       };
30537     } catch (...) {
30538       {
30539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30540       };
30541     }
30542   }
30543
30544 }
30545
30546
30547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30548   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30549
30550   arg1 = (Dali::GestureDetector *)jarg1;
30551   {
30552     try {
30553       (arg1)->DetachAll();
30554     } catch (std::out_of_range& e) {
30555       {
30556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30557       };
30558     } catch (std::exception& e) {
30559       {
30560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30561       };
30562     } catch (Dali::DaliException e) {
30563       {
30564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30565       };
30566     } catch (...) {
30567       {
30568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30569       };
30570     }
30571   }
30572
30573 }
30574
30575
30576 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30577   unsigned long jresult ;
30578   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30579   size_t result;
30580
30581   arg1 = (Dali::GestureDetector *)jarg1;
30582   {
30583     try {
30584       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30585     } catch (std::out_of_range& e) {
30586       {
30587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30588       };
30589     } catch (std::exception& e) {
30590       {
30591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30592       };
30593     } catch (Dali::DaliException e) {
30594       {
30595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30596       };
30597     } catch (...) {
30598       {
30599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30600       };
30601     }
30602   }
30603
30604   jresult = (unsigned long)result;
30605   return jresult;
30606 }
30607
30608
30609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30610   void * jresult ;
30611   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30612   size_t arg2 ;
30613   Dali::Actor result;
30614
30615   arg1 = (Dali::GestureDetector *)jarg1;
30616   arg2 = (size_t)jarg2;
30617   {
30618     try {
30619       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30620     } catch (std::out_of_range& e) {
30621       {
30622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30623       };
30624     } catch (std::exception& e) {
30625       {
30626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30627       };
30628     } catch (Dali::DaliException e) {
30629       {
30630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30631       };
30632     } catch (...) {
30633       {
30634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30635       };
30636     }
30637   }
30638
30639   jresult = new Dali::Actor((const Dali::Actor &)result);
30640   return jresult;
30641 }
30642
30643
30644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30645   void * jresult ;
30646   Dali::Gesture *arg1 = 0 ;
30647   Dali::Gesture *result = 0 ;
30648
30649   arg1 = (Dali::Gesture *)jarg1;
30650   if (!arg1) {
30651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30652     return 0;
30653   }
30654   {
30655     try {
30656       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30657     } catch (std::out_of_range& e) {
30658       {
30659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30660       };
30661     } catch (std::exception& e) {
30662       {
30663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30664       };
30665     } catch (Dali::DaliException e) {
30666       {
30667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30668       };
30669     } catch (...) {
30670       {
30671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30672       };
30673     }
30674   }
30675
30676   jresult = (void *)result;
30677   return jresult;
30678 }
30679
30680
30681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30682   void * jresult ;
30683   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30684   Dali::Gesture *arg2 = 0 ;
30685   Dali::Gesture *result = 0 ;
30686
30687   arg1 = (Dali::Gesture *)jarg1;
30688   arg2 = (Dali::Gesture *)jarg2;
30689   if (!arg2) {
30690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30691     return 0;
30692   }
30693   {
30694     try {
30695       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30696     } catch (std::out_of_range& e) {
30697       {
30698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30699       };
30700     } catch (std::exception& e) {
30701       {
30702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30703       };
30704     } catch (Dali::DaliException e) {
30705       {
30706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30707       };
30708     } catch (...) {
30709       {
30710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30711       };
30712     }
30713   }
30714
30715   jresult = (void *)result;
30716   return jresult;
30717 }
30718
30719
30720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30721   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30722
30723   arg1 = (Dali::Gesture *)jarg1;
30724   {
30725     try {
30726       delete arg1;
30727     } catch (std::out_of_range& e) {
30728       {
30729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30730       };
30731     } catch (std::exception& e) {
30732       {
30733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30734       };
30735     } catch (Dali::DaliException e) {
30736       {
30737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30738       };
30739     } catch (...) {
30740       {
30741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30742       };
30743     }
30744   }
30745
30746 }
30747
30748
30749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30750   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30751   Dali::Gesture::Type arg2 ;
30752
30753   arg1 = (Dali::Gesture *)jarg1;
30754   arg2 = (Dali::Gesture::Type)jarg2;
30755   if (arg1) (arg1)->type = arg2;
30756 }
30757
30758
30759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30760   int jresult ;
30761   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30762   Dali::Gesture::Type result;
30763
30764   arg1 = (Dali::Gesture *)jarg1;
30765   result = (Dali::Gesture::Type) ((arg1)->type);
30766   jresult = (int)result;
30767   return jresult;
30768 }
30769
30770
30771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30772   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30773   Dali::Gesture::State arg2 ;
30774
30775   arg1 = (Dali::Gesture *)jarg1;
30776   arg2 = (Dali::Gesture::State)jarg2;
30777   if (arg1) (arg1)->state = arg2;
30778 }
30779
30780
30781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30782   int jresult ;
30783   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30784   Dali::Gesture::State result;
30785
30786   arg1 = (Dali::Gesture *)jarg1;
30787   result = (Dali::Gesture::State) ((arg1)->state);
30788   jresult = (int)result;
30789   return jresult;
30790 }
30791
30792
30793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30794   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30795   unsigned int arg2 ;
30796
30797   arg1 = (Dali::Gesture *)jarg1;
30798   arg2 = (unsigned int)jarg2;
30799   if (arg1) (arg1)->time = arg2;
30800 }
30801
30802
30803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30804   unsigned int jresult ;
30805   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30806   unsigned int result;
30807
30808   arg1 = (Dali::Gesture *)jarg1;
30809   result = (unsigned int) ((arg1)->time);
30810   jresult = result;
30811   return jresult;
30812 }
30813
30814
30815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30816   void * jresult ;
30817   Dali::HoverEvent *result = 0 ;
30818
30819   {
30820     try {
30821       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30822     } catch (std::out_of_range& e) {
30823       {
30824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30825       };
30826     } catch (std::exception& e) {
30827       {
30828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30829       };
30830     } catch (Dali::DaliException e) {
30831       {
30832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30833       };
30834     } catch (...) {
30835       {
30836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30837       };
30838     }
30839   }
30840
30841   jresult = (void *)result;
30842   return jresult;
30843 }
30844
30845
30846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30847   void * jresult ;
30848   unsigned long arg1 ;
30849   Dali::HoverEvent *result = 0 ;
30850
30851   arg1 = (unsigned long)jarg1;
30852   {
30853     try {
30854       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30855     } catch (std::out_of_range& e) {
30856       {
30857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30858       };
30859     } catch (std::exception& e) {
30860       {
30861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30862       };
30863     } catch (Dali::DaliException e) {
30864       {
30865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30866       };
30867     } catch (...) {
30868       {
30869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30870       };
30871     }
30872   }
30873
30874   jresult = (void *)result;
30875   return jresult;
30876 }
30877
30878
30879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30880   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30881
30882   arg1 = (Dali::HoverEvent *)jarg1;
30883   {
30884     try {
30885       delete arg1;
30886     } catch (std::out_of_range& e) {
30887       {
30888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30889       };
30890     } catch (std::exception& e) {
30891       {
30892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30893       };
30894     } catch (Dali::DaliException e) {
30895       {
30896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30897       };
30898     } catch (...) {
30899       {
30900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30901       };
30902     }
30903   }
30904
30905 }
30906
30907
30908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30909   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30910   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30911
30912   arg1 = (Dali::HoverEvent *)jarg1;
30913   arg2 = (Dali::TouchPointContainer *)jarg2;
30914   if (arg1) (arg1)->points = *arg2;
30915 }
30916
30917
30918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30919   void * jresult ;
30920   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30921   Dali::TouchPointContainer *result = 0 ;
30922
30923   arg1 = (Dali::HoverEvent *)jarg1;
30924   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30925   jresult = (void *)result;
30926   return jresult;
30927 }
30928
30929
30930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30931   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30932   unsigned long arg2 ;
30933
30934   arg1 = (Dali::HoverEvent *)jarg1;
30935   arg2 = (unsigned long)jarg2;
30936   if (arg1) (arg1)->time = arg2;
30937 }
30938
30939
30940 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30941   unsigned long jresult ;
30942   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30943   unsigned long result;
30944
30945   arg1 = (Dali::HoverEvent *)jarg1;
30946   result = (unsigned long) ((arg1)->time);
30947   jresult = (unsigned long)result;
30948   return jresult;
30949 }
30950
30951
30952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30953   unsigned int jresult ;
30954   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30955   unsigned int result;
30956
30957   arg1 = (Dali::HoverEvent *)jarg1;
30958   {
30959     try {
30960       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30961     } catch (std::out_of_range& e) {
30962       {
30963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30964       };
30965     } catch (std::exception& e) {
30966       {
30967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30968       };
30969     } catch (Dali::DaliException e) {
30970       {
30971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30972       };
30973     } catch (...) {
30974       {
30975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30976       };
30977     }
30978   }
30979
30980   jresult = result;
30981   return jresult;
30982 }
30983
30984
30985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30986   void * jresult ;
30987   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30988   unsigned int arg2 ;
30989   Dali::TouchPoint *result = 0 ;
30990
30991   arg1 = (Dali::HoverEvent *)jarg1;
30992   arg2 = (unsigned int)jarg2;
30993   {
30994     try {
30995       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30996     } catch (std::out_of_range& e) {
30997       {
30998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30999       };
31000     } catch (std::exception& e) {
31001       {
31002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31003       };
31004     } catch (Dali::DaliException e) {
31005       {
31006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31007       };
31008     } catch (...) {
31009       {
31010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31011       };
31012     }
31013   }
31014
31015   jresult = (void *)result;
31016   return jresult;
31017 }
31018
31019
31020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31021   void * jresult ;
31022   Dali::KeyEvent *result = 0 ;
31023
31024   {
31025     try {
31026       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31027     } catch (std::out_of_range& e) {
31028       {
31029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31030       };
31031     } catch (std::exception& e) {
31032       {
31033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31034       };
31035     } catch (Dali::DaliException e) {
31036       {
31037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31038       };
31039     } catch (...) {
31040       {
31041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31042       };
31043     }
31044   }
31045
31046   jresult = (void *)result;
31047   return jresult;
31048 }
31049
31050
31051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31052   void * jresult ;
31053   std::string *arg1 = 0 ;
31054   std::string *arg2 = 0 ;
31055   int arg3 ;
31056   int arg4 ;
31057   unsigned long arg5 ;
31058   Dali::KeyEvent::State *arg6 = 0 ;
31059   Dali::KeyEvent::State temp6 ;
31060   Dali::KeyEvent *result = 0 ;
31061
31062   if (!jarg1) {
31063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31064     return 0;
31065   }
31066   std::string arg1_str(jarg1);
31067   arg1 = &arg1_str;
31068   if (!jarg2) {
31069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31070     return 0;
31071   }
31072   std::string arg2_str(jarg2);
31073   arg2 = &arg2_str;
31074   arg3 = (int)jarg3;
31075   arg4 = (int)jarg4;
31076   arg5 = (unsigned long)jarg5;
31077   temp6 = (Dali::KeyEvent::State)jarg6;
31078   arg6 = &temp6;
31079   {
31080     try {
31081       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31082     } catch (std::out_of_range& e) {
31083       {
31084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31085       };
31086     } catch (std::exception& e) {
31087       {
31088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31089       };
31090     } catch (Dali::DaliException e) {
31091       {
31092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31093       };
31094     } catch (...) {
31095       {
31096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31097       };
31098     }
31099   }
31100
31101   jresult = (void *)result;
31102
31103   //argout typemap for const std::string&
31104
31105
31106   //argout typemap for const std::string&
31107
31108   return jresult;
31109 }
31110
31111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31112   void * jresult ;
31113   Dali::KeyEvent *arg1 = 0 ;
31114   Dali::KeyEvent *result = 0 ;
31115
31116   arg1 = (Dali::KeyEvent *)jarg1;
31117   if (!arg1) {
31118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31119     return 0;
31120   }
31121   {
31122     try {
31123       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31124     } catch (std::out_of_range& e) {
31125       {
31126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31127       };
31128     } catch (std::exception& e) {
31129       {
31130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31131       };
31132     } catch (Dali::DaliException e) {
31133       {
31134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31135       };
31136     } catch (...) {
31137       {
31138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31139       };
31140     }
31141   }
31142
31143   jresult = (void *)result;
31144   return jresult;
31145 }
31146
31147
31148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31149   void * jresult ;
31150   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31151   Dali::KeyEvent *arg2 = 0 ;
31152   Dali::KeyEvent *result = 0 ;
31153
31154   arg1 = (Dali::KeyEvent *)jarg1;
31155   arg2 = (Dali::KeyEvent *)jarg2;
31156   if (!arg2) {
31157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31158     return 0;
31159   }
31160   {
31161     try {
31162       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31163     } catch (std::out_of_range& e) {
31164       {
31165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31166       };
31167     } catch (std::exception& e) {
31168       {
31169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31170       };
31171     } catch (Dali::DaliException e) {
31172       {
31173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31174       };
31175     } catch (...) {
31176       {
31177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31178       };
31179     }
31180   }
31181
31182   jresult = (void *)result;
31183   return jresult;
31184 }
31185
31186
31187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31188   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31189
31190   arg1 = (Dali::KeyEvent *)jarg1;
31191   {
31192     try {
31193       delete arg1;
31194     } catch (std::out_of_range& e) {
31195       {
31196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31197       };
31198     } catch (std::exception& e) {
31199       {
31200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31201       };
31202     } catch (Dali::DaliException e) {
31203       {
31204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31205       };
31206     } catch (...) {
31207       {
31208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31209       };
31210     }
31211   }
31212
31213 }
31214
31215
31216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31217   unsigned int jresult ;
31218   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31219   bool result;
31220
31221   arg1 = (Dali::KeyEvent *)jarg1;
31222   {
31223     try {
31224       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31225     } catch (std::out_of_range& e) {
31226       {
31227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31228       };
31229     } catch (std::exception& e) {
31230       {
31231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31232       };
31233     } catch (Dali::DaliException e) {
31234       {
31235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31236       };
31237     } catch (...) {
31238       {
31239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31240       };
31241     }
31242   }
31243
31244   jresult = result;
31245   return jresult;
31246 }
31247
31248
31249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31250   unsigned int jresult ;
31251   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31252   bool result;
31253
31254   arg1 = (Dali::KeyEvent *)jarg1;
31255   {
31256     try {
31257       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31258     } catch (std::out_of_range& e) {
31259       {
31260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31261       };
31262     } catch (std::exception& e) {
31263       {
31264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31265       };
31266     } catch (Dali::DaliException e) {
31267       {
31268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31269       };
31270     } catch (...) {
31271       {
31272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31273       };
31274     }
31275   }
31276
31277   jresult = result;
31278   return jresult;
31279 }
31280
31281
31282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31283   unsigned int jresult ;
31284   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31285   bool result;
31286
31287   arg1 = (Dali::KeyEvent *)jarg1;
31288   {
31289     try {
31290       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31291     } catch (std::out_of_range& e) {
31292       {
31293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31294       };
31295     } catch (std::exception& e) {
31296       {
31297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31298       };
31299     } catch (Dali::DaliException e) {
31300       {
31301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31302       };
31303     } catch (...) {
31304       {
31305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31306       };
31307     }
31308   }
31309
31310   jresult = result;
31311   return jresult;
31312 }
31313
31314
31315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31316   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31317   std::string *arg2 = 0 ;
31318
31319   arg1 = (Dali::KeyEvent *)jarg1;
31320   if (!jarg2) {
31321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31322     return ;
31323   }
31324   std::string arg2_str(jarg2);
31325   arg2 = &arg2_str;
31326   if (arg1) (arg1)->keyPressedName = *arg2;
31327
31328   //argout typemap for const std::string&
31329
31330 }
31331
31332
31333 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31334   char * jresult ;
31335
31336   if( jarg1 == NULL )
31337   {
31338     jresult = SWIG_csharp_string_callback( "" );
31339   }
31340   else
31341   {
31342     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31343     std::string *result = 0;
31344
31345     arg1 = ( Dali::KeyEvent * )jarg1;
31346     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31347     jresult = SWIG_csharp_string_callback( result->c_str() );
31348   }
31349
31350   return jresult;
31351 }
31352
31353
31354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31355   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31356   std::string *arg2 = 0 ;
31357
31358   arg1 = (Dali::KeyEvent *)jarg1;
31359   if (!jarg2) {
31360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31361     return ;
31362   }
31363   std::string arg2_str(jarg2);
31364   arg2 = &arg2_str;
31365   if (arg1) (arg1)->keyPressed = *arg2;
31366
31367   //argout typemap for const std::string&
31368
31369 }
31370
31371
31372 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31373   char * jresult ;
31374   if( NULL == jarg1 )
31375   {
31376     jresult = SWIG_csharp_string_callback( "" );
31377   }
31378   else
31379   {
31380     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31381     std::string *result = 0;
31382
31383     arg1 = ( Dali::KeyEvent * )jarg1;
31384     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31385     jresult = SWIG_csharp_string_callback( result->c_str() );
31386   }
31387   return jresult;
31388 }
31389
31390
31391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31392   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31393   int arg2 ;
31394
31395   arg1 = (Dali::KeyEvent *)jarg1;
31396   arg2 = (int)jarg2;
31397   if (arg1) (arg1)->keyCode = arg2;
31398 }
31399
31400
31401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31402   int jresult ;
31403   if( NULL == jarg1 )
31404   {
31405     jresult = -1;
31406   }
31407   else
31408   {
31409     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31410     int result;
31411
31412     arg1 = ( Dali::KeyEvent * )jarg1;
31413     result = (int)( ( arg1 )->keyCode );
31414     jresult = result;
31415   }
31416   return jresult;
31417 }
31418
31419
31420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31421   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31422   int arg2 ;
31423
31424   arg1 = (Dali::KeyEvent *)jarg1;
31425   arg2 = (int)jarg2;
31426   if (arg1) (arg1)->keyModifier = arg2;
31427 }
31428
31429
31430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31431   int jresult ;
31432   if( jarg1 == NULL )
31433   {
31434     jresult = -1;
31435   }
31436   else
31437   {
31438     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31439     int result;
31440
31441     arg1 = ( Dali::KeyEvent * )jarg1;
31442     result = (int)( ( arg1 )->keyModifier );
31443     jresult = result;
31444   }
31445   return jresult;
31446 }
31447
31448
31449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31450   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31451   unsigned long arg2 ;
31452
31453   arg1 = (Dali::KeyEvent *)jarg1;
31454   arg2 = (unsigned long)jarg2;
31455   if (arg1) (arg1)->time = arg2;
31456 }
31457
31458
31459 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31460   unsigned long jresult ;
31461   if( jarg1 == NULL )
31462   {
31463     jresult = 0;
31464   }
31465   else
31466   {
31467     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31468     unsigned long result;
31469
31470     arg1 = ( Dali::KeyEvent * )jarg1;
31471     result = (unsigned long)( ( arg1 )->time );
31472     jresult = (unsigned long)result;
31473   }
31474   return jresult;
31475 }
31476
31477
31478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31479   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31480   Dali::KeyEvent::State arg2 ;
31481
31482   arg1 = (Dali::KeyEvent *)jarg1;
31483   arg2 = (Dali::KeyEvent::State)jarg2;
31484   if (arg1) (arg1)->state = arg2;
31485 }
31486
31487
31488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31489   int jresult ;
31490   if( jarg1 == NULL )
31491   {
31492     jresult = -1;
31493   }
31494   else
31495   {
31496     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31497     Dali::KeyEvent::State result;
31498
31499     arg1 = ( Dali::KeyEvent * )jarg1;
31500     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31501     jresult = (int)result;
31502   }
31503   return jresult;
31504 }
31505
31506
31507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31508   void * jresult ;
31509   Dali::LongPressGestureDetector *result = 0 ;
31510
31511   {
31512     try {
31513       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31514     } catch (std::out_of_range& e) {
31515       {
31516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31517       };
31518     } catch (std::exception& e) {
31519       {
31520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31521       };
31522     } catch (Dali::DaliException e) {
31523       {
31524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31525       };
31526     } catch (...) {
31527       {
31528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31529       };
31530     }
31531   }
31532
31533   jresult = (void *)result;
31534   return jresult;
31535 }
31536
31537
31538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31539   void * jresult ;
31540   Dali::LongPressGestureDetector result;
31541
31542   {
31543     try {
31544       result = Dali::LongPressGestureDetector::New();
31545     } catch (std::out_of_range& e) {
31546       {
31547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31548       };
31549     } catch (std::exception& e) {
31550       {
31551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31552       };
31553     } catch (Dali::DaliException e) {
31554       {
31555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31556       };
31557     } catch (...) {
31558       {
31559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31560       };
31561     }
31562   }
31563
31564   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31565   return jresult;
31566 }
31567
31568
31569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31570   void * jresult ;
31571   unsigned int arg1 ;
31572   Dali::LongPressGestureDetector result;
31573
31574   arg1 = (unsigned int)jarg1;
31575   {
31576     try {
31577       result = Dali::LongPressGestureDetector::New(arg1);
31578     } catch (std::out_of_range& e) {
31579       {
31580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31581       };
31582     } catch (std::exception& e) {
31583       {
31584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31585       };
31586     } catch (Dali::DaliException e) {
31587       {
31588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31589       };
31590     } catch (...) {
31591       {
31592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31593       };
31594     }
31595   }
31596
31597   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31598   return jresult;
31599 }
31600
31601
31602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31603   void * jresult ;
31604   unsigned int arg1 ;
31605   unsigned int arg2 ;
31606   Dali::LongPressGestureDetector result;
31607
31608   arg1 = (unsigned int)jarg1;
31609   arg2 = (unsigned int)jarg2;
31610   {
31611     try {
31612       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31613     } catch (std::out_of_range& e) {
31614       {
31615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31616       };
31617     } catch (std::exception& e) {
31618       {
31619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31620       };
31621     } catch (Dali::DaliException e) {
31622       {
31623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31624       };
31625     } catch (...) {
31626       {
31627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31628       };
31629     }
31630   }
31631
31632   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31633   return jresult;
31634 }
31635
31636
31637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31638   void * jresult ;
31639   Dali::BaseHandle arg1 ;
31640   Dali::BaseHandle *argp1 ;
31641   Dali::LongPressGestureDetector result;
31642
31643   argp1 = (Dali::BaseHandle *)jarg1;
31644   if (!argp1) {
31645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31646     return 0;
31647   }
31648   arg1 = *argp1;
31649   {
31650     try {
31651       result = Dali::LongPressGestureDetector::DownCast(arg1);
31652     } catch (std::out_of_range& e) {
31653       {
31654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31655       };
31656     } catch (std::exception& e) {
31657       {
31658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31659       };
31660     } catch (Dali::DaliException e) {
31661       {
31662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31663       };
31664     } catch (...) {
31665       {
31666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31667       };
31668     }
31669   }
31670
31671   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31672   return jresult;
31673 }
31674
31675
31676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31677   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31678
31679   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31680   {
31681     try {
31682       delete arg1;
31683     } catch (std::out_of_range& e) {
31684       {
31685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31686       };
31687     } catch (std::exception& e) {
31688       {
31689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31690       };
31691     } catch (Dali::DaliException e) {
31692       {
31693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31694       };
31695     } catch (...) {
31696       {
31697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31698       };
31699     }
31700   }
31701
31702 }
31703
31704
31705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31706   void * jresult ;
31707   Dali::LongPressGestureDetector *arg1 = 0 ;
31708   Dali::LongPressGestureDetector *result = 0 ;
31709
31710   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31711   if (!arg1) {
31712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31713     return 0;
31714   }
31715   {
31716     try {
31717       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31718     } catch (std::out_of_range& e) {
31719       {
31720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31721       };
31722     } catch (std::exception& e) {
31723       {
31724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31725       };
31726     } catch (Dali::DaliException e) {
31727       {
31728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31729       };
31730     } catch (...) {
31731       {
31732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31733       };
31734     }
31735   }
31736
31737   jresult = (void *)result;
31738   return jresult;
31739 }
31740
31741
31742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31743   void * jresult ;
31744   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31745   Dali::LongPressGestureDetector *arg2 = 0 ;
31746   Dali::LongPressGestureDetector *result = 0 ;
31747
31748   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31749   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31750   if (!arg2) {
31751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31752     return 0;
31753   }
31754   {
31755     try {
31756       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31757     } catch (std::out_of_range& e) {
31758       {
31759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31760       };
31761     } catch (std::exception& e) {
31762       {
31763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31764       };
31765     } catch (Dali::DaliException e) {
31766       {
31767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31768       };
31769     } catch (...) {
31770       {
31771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31772       };
31773     }
31774   }
31775
31776   jresult = (void *)result;
31777   return jresult;
31778 }
31779
31780
31781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31782   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31783   unsigned int arg2 ;
31784
31785   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31786   arg2 = (unsigned int)jarg2;
31787   {
31788     try {
31789       (arg1)->SetTouchesRequired(arg2);
31790     } catch (std::out_of_range& e) {
31791       {
31792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31793       };
31794     } catch (std::exception& e) {
31795       {
31796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31797       };
31798     } catch (Dali::DaliException e) {
31799       {
31800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31801       };
31802     } catch (...) {
31803       {
31804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31805       };
31806     }
31807   }
31808
31809 }
31810
31811
31812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31813   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31814   unsigned int arg2 ;
31815   unsigned int arg3 ;
31816
31817   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31818   arg2 = (unsigned int)jarg2;
31819   arg3 = (unsigned int)jarg3;
31820   {
31821     try {
31822       (arg1)->SetTouchesRequired(arg2,arg3);
31823     } catch (std::out_of_range& e) {
31824       {
31825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31826       };
31827     } catch (std::exception& e) {
31828       {
31829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31830       };
31831     } catch (Dali::DaliException e) {
31832       {
31833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31834       };
31835     } catch (...) {
31836       {
31837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31838       };
31839     }
31840   }
31841
31842 }
31843
31844
31845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31846   unsigned int jresult ;
31847   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31848   unsigned int result;
31849
31850   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31851   {
31852     try {
31853       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31854     } catch (std::out_of_range& e) {
31855       {
31856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31857       };
31858     } catch (std::exception& e) {
31859       {
31860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31861       };
31862     } catch (Dali::DaliException e) {
31863       {
31864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31865       };
31866     } catch (...) {
31867       {
31868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31869       };
31870     }
31871   }
31872
31873   jresult = result;
31874   return jresult;
31875 }
31876
31877
31878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31879   unsigned int jresult ;
31880   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31881   unsigned int result;
31882
31883   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31884   {
31885     try {
31886       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31887     } catch (std::out_of_range& e) {
31888       {
31889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31890       };
31891     } catch (std::exception& e) {
31892       {
31893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31894       };
31895     } catch (Dali::DaliException e) {
31896       {
31897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31898       };
31899     } catch (...) {
31900       {
31901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31902       };
31903     }
31904   }
31905
31906   jresult = result;
31907   return jresult;
31908 }
31909
31910
31911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31912   void * jresult ;
31913   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31914   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31915
31916   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31917   {
31918     try {
31919       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31920     } catch (std::out_of_range& e) {
31921       {
31922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31923       };
31924     } catch (std::exception& e) {
31925       {
31926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31927       };
31928     } catch (Dali::DaliException e) {
31929       {
31930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31931       };
31932     } catch (...) {
31933       {
31934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31935       };
31936     }
31937   }
31938
31939   jresult = (void *)result;
31940   return jresult;
31941 }
31942
31943
31944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31945   void * jresult ;
31946   Dali::Gesture::State arg1 ;
31947   Dali::LongPressGesture *result = 0 ;
31948
31949   arg1 = (Dali::Gesture::State)jarg1;
31950   {
31951     try {
31952       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31953     } catch (std::out_of_range& e) {
31954       {
31955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31956       };
31957     } catch (std::exception& e) {
31958       {
31959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31960       };
31961     } catch (Dali::DaliException e) {
31962       {
31963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31964       };
31965     } catch (...) {
31966       {
31967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31968       };
31969     }
31970   }
31971
31972   jresult = (void *)result;
31973   return jresult;
31974 }
31975
31976
31977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31978   void * jresult ;
31979   Dali::LongPressGesture *arg1 = 0 ;
31980   Dali::LongPressGesture *result = 0 ;
31981
31982   arg1 = (Dali::LongPressGesture *)jarg1;
31983   if (!arg1) {
31984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31985     return 0;
31986   }
31987   {
31988     try {
31989       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31990     } catch (std::out_of_range& e) {
31991       {
31992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31993       };
31994     } catch (std::exception& e) {
31995       {
31996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31997       };
31998     } catch (Dali::DaliException e) {
31999       {
32000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32001       };
32002     } catch (...) {
32003       {
32004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32005       };
32006     }
32007   }
32008
32009   jresult = (void *)result;
32010   return jresult;
32011 }
32012
32013
32014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32015   void * jresult ;
32016   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32017   Dali::LongPressGesture *arg2 = 0 ;
32018   Dali::LongPressGesture *result = 0 ;
32019
32020   arg1 = (Dali::LongPressGesture *)jarg1;
32021   arg2 = (Dali::LongPressGesture *)jarg2;
32022   if (!arg2) {
32023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32024     return 0;
32025   }
32026   {
32027     try {
32028       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32029     } catch (std::out_of_range& e) {
32030       {
32031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32032       };
32033     } catch (std::exception& e) {
32034       {
32035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32036       };
32037     } catch (Dali::DaliException e) {
32038       {
32039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32040       };
32041     } catch (...) {
32042       {
32043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32044       };
32045     }
32046   }
32047
32048   jresult = (void *)result;
32049   return jresult;
32050 }
32051
32052
32053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32054   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32055
32056   arg1 = (Dali::LongPressGesture *)jarg1;
32057   {
32058     try {
32059       delete arg1;
32060     } catch (std::out_of_range& e) {
32061       {
32062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32063       };
32064     } catch (std::exception& e) {
32065       {
32066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32067       };
32068     } catch (Dali::DaliException e) {
32069       {
32070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32071       };
32072     } catch (...) {
32073       {
32074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32075       };
32076     }
32077   }
32078
32079 }
32080
32081
32082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32083   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32084   unsigned int arg2 ;
32085
32086   arg1 = (Dali::LongPressGesture *)jarg1;
32087   arg2 = (unsigned int)jarg2;
32088   if (arg1) (arg1)->numberOfTouches = arg2;
32089 }
32090
32091
32092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32093   unsigned int jresult ;
32094   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32095   unsigned int result;
32096
32097   arg1 = (Dali::LongPressGesture *)jarg1;
32098   result = (unsigned int) ((arg1)->numberOfTouches);
32099   jresult = result;
32100   return jresult;
32101 }
32102
32103
32104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32105   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32106   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32107
32108   arg1 = (Dali::LongPressGesture *)jarg1;
32109   arg2 = (Dali::Vector2 *)jarg2;
32110   if (arg1) (arg1)->screenPoint = *arg2;
32111 }
32112
32113
32114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32115   void * jresult ;
32116   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32117   Dali::Vector2 *result = 0 ;
32118
32119   arg1 = (Dali::LongPressGesture *)jarg1;
32120   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32121   jresult = (void *)result;
32122   return jresult;
32123 }
32124
32125
32126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32127   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32128   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32129
32130   arg1 = (Dali::LongPressGesture *)jarg1;
32131   arg2 = (Dali::Vector2 *)jarg2;
32132   if (arg1) (arg1)->localPoint = *arg2;
32133 }
32134
32135
32136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32137   void * jresult ;
32138   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32139   Dali::Vector2 *result = 0 ;
32140
32141   arg1 = (Dali::LongPressGesture *)jarg1;
32142   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32143   jresult = (void *)result;
32144   return jresult;
32145 }
32146
32147
32148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32149   void * jresult ;
32150   Dali::WheelEvent *result = 0 ;
32151
32152   {
32153     try {
32154       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32155     } catch (std::out_of_range& e) {
32156       {
32157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32158       };
32159     } catch (std::exception& e) {
32160       {
32161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32162       };
32163     } catch (Dali::DaliException e) {
32164       {
32165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32166       };
32167     } catch (...) {
32168       {
32169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32170       };
32171     }
32172   }
32173
32174   jresult = (void *)result;
32175   return jresult;
32176 }
32177
32178
32179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32180   void * jresult ;
32181   Dali::WheelEvent::Type arg1 ;
32182   int arg2 ;
32183   unsigned int arg3 ;
32184   Dali::Vector2 arg4 ;
32185   int arg5 ;
32186   unsigned int arg6 ;
32187   Dali::Vector2 *argp4 ;
32188   Dali::WheelEvent *result = 0 ;
32189
32190   arg1 = (Dali::WheelEvent::Type)jarg1;
32191   arg2 = (int)jarg2;
32192   arg3 = (unsigned int)jarg3;
32193   argp4 = (Dali::Vector2 *)jarg4;
32194   if (!argp4) {
32195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32196     return 0;
32197   }
32198   arg4 = *argp4;
32199   arg5 = (int)jarg5;
32200   arg6 = (unsigned int)jarg6;
32201   {
32202     try {
32203       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32204     } catch (std::out_of_range& e) {
32205       {
32206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32207       };
32208     } catch (std::exception& e) {
32209       {
32210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32211       };
32212     } catch (Dali::DaliException e) {
32213       {
32214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32215       };
32216     } catch (...) {
32217       {
32218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32219       };
32220     }
32221   }
32222
32223   jresult = (void *)result;
32224   return jresult;
32225 }
32226
32227
32228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32229   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32230
32231   arg1 = (Dali::WheelEvent *)jarg1;
32232   {
32233     try {
32234       delete arg1;
32235     } catch (std::out_of_range& e) {
32236       {
32237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32238       };
32239     } catch (std::exception& e) {
32240       {
32241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32242       };
32243     } catch (Dali::DaliException e) {
32244       {
32245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32246       };
32247     } catch (...) {
32248       {
32249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32250       };
32251     }
32252   }
32253
32254 }
32255
32256
32257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32258   unsigned int jresult ;
32259   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32260   bool result;
32261
32262   arg1 = (Dali::WheelEvent *)jarg1;
32263   {
32264     try {
32265       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32266     } catch (std::out_of_range& e) {
32267       {
32268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32269       };
32270     } catch (std::exception& e) {
32271       {
32272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32273       };
32274     } catch (Dali::DaliException e) {
32275       {
32276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32277       };
32278     } catch (...) {
32279       {
32280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32281       };
32282     }
32283   }
32284
32285   jresult = result;
32286   return jresult;
32287 }
32288
32289
32290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32291   unsigned int jresult ;
32292   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32293   bool result;
32294
32295   arg1 = (Dali::WheelEvent *)jarg1;
32296   {
32297     try {
32298       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32299     } catch (std::out_of_range& e) {
32300       {
32301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32302       };
32303     } catch (std::exception& e) {
32304       {
32305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32306       };
32307     } catch (Dali::DaliException e) {
32308       {
32309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32310       };
32311     } catch (...) {
32312       {
32313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32314       };
32315     }
32316   }
32317
32318   jresult = result;
32319   return jresult;
32320 }
32321
32322
32323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32324   unsigned int jresult ;
32325   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32326   bool result;
32327
32328   arg1 = (Dali::WheelEvent *)jarg1;
32329   {
32330     try {
32331       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32332     } catch (std::out_of_range& e) {
32333       {
32334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32335       };
32336     } catch (std::exception& e) {
32337       {
32338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32339       };
32340     } catch (Dali::DaliException e) {
32341       {
32342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32343       };
32344     } catch (...) {
32345       {
32346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32347       };
32348     }
32349   }
32350
32351   jresult = result;
32352   return jresult;
32353 }
32354
32355
32356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32357   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32358   Dali::WheelEvent::Type arg2 ;
32359
32360   arg1 = (Dali::WheelEvent *)jarg1;
32361   arg2 = (Dali::WheelEvent::Type)jarg2;
32362   if (arg1) (arg1)->type = arg2;
32363 }
32364
32365
32366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32367   int jresult ;
32368   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32369   Dali::WheelEvent::Type result;
32370
32371   arg1 = (Dali::WheelEvent *)jarg1;
32372   result = (Dali::WheelEvent::Type) ((arg1)->type);
32373   jresult = (int)result;
32374   return jresult;
32375 }
32376
32377
32378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32379   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32380   int arg2 ;
32381
32382   arg1 = (Dali::WheelEvent *)jarg1;
32383   arg2 = (int)jarg2;
32384   if (arg1) (arg1)->direction = arg2;
32385 }
32386
32387
32388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32389   int jresult ;
32390   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32391   int result;
32392
32393   arg1 = (Dali::WheelEvent *)jarg1;
32394   result = (int) ((arg1)->direction);
32395   jresult = result;
32396   return jresult;
32397 }
32398
32399
32400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32401   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32402   unsigned int arg2 ;
32403
32404   arg1 = (Dali::WheelEvent *)jarg1;
32405   arg2 = (unsigned int)jarg2;
32406   if (arg1) (arg1)->modifiers = arg2;
32407 }
32408
32409
32410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32411   unsigned int jresult ;
32412   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32413   unsigned int result;
32414
32415   arg1 = (Dali::WheelEvent *)jarg1;
32416   result = (unsigned int) ((arg1)->modifiers);
32417   jresult = result;
32418   return jresult;
32419 }
32420
32421
32422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32423   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32424   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32425
32426   arg1 = (Dali::WheelEvent *)jarg1;
32427   arg2 = (Dali::Vector2 *)jarg2;
32428   if (arg1) (arg1)->point = *arg2;
32429 }
32430
32431
32432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32433   void * jresult ;
32434   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32435   Dali::Vector2 *result = 0 ;
32436
32437   arg1 = (Dali::WheelEvent *)jarg1;
32438   result = (Dali::Vector2 *)& ((arg1)->point);
32439   jresult = (void *)result;
32440   return jresult;
32441 }
32442
32443
32444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32445   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32446   int arg2 ;
32447
32448   arg1 = (Dali::WheelEvent *)jarg1;
32449   arg2 = (int)jarg2;
32450   if (arg1) (arg1)->z = arg2;
32451 }
32452
32453
32454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32455   int jresult ;
32456   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32457   int result;
32458
32459   arg1 = (Dali::WheelEvent *)jarg1;
32460   result = (int) ((arg1)->z);
32461   jresult = result;
32462   return jresult;
32463 }
32464
32465
32466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32467   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32468   unsigned int arg2 ;
32469
32470   arg1 = (Dali::WheelEvent *)jarg1;
32471   arg2 = (unsigned int)jarg2;
32472   if (arg1) (arg1)->timeStamp = arg2;
32473 }
32474
32475
32476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32477   unsigned int jresult ;
32478   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32479   unsigned int result;
32480
32481   arg1 = (Dali::WheelEvent *)jarg1;
32482   result = (unsigned int) ((arg1)->timeStamp);
32483   jresult = result;
32484   return jresult;
32485 }
32486
32487 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32488   char * jresult ;
32489   Dali::KeyEvent *arg1 = 0 ;
32490   std::string result;
32491
32492   arg1 = (Dali::KeyEvent *)jarg1;
32493   if (!arg1) {
32494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32495     return 0;
32496   }
32497   {
32498     try {
32499       result = arg1->GetDeviceName();
32500     } catch (std::out_of_range& e) {
32501       {
32502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32503       };
32504     } catch (std::exception& e) {
32505       {
32506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32507       };
32508     } catch (Dali::DaliException e) {
32509       {
32510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32511       };
32512     } catch (...) {
32513       {
32514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32515       };
32516     }
32517   }
32518
32519   jresult = SWIG_csharp_string_callback((&result)->c_str());
32520   return jresult;
32521 }
32522
32523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32524   int jresult ;
32525   Dali::KeyEvent *arg1 = 0 ;
32526   Dali::Device::Class::Type result;
32527
32528   arg1 = (Dali::KeyEvent *)jarg1;
32529   if (!arg1) {
32530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32531     return 0;
32532   }
32533   {
32534     try {
32535       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32536     } catch (std::out_of_range& e) {
32537       {
32538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32539       };
32540     } catch (std::exception& e) {
32541       {
32542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32543       };
32544     } catch (Dali::DaliException e) {
32545       {
32546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32547       };
32548     } catch (...) {
32549       {
32550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32551       };
32552     }
32553   }
32554
32555   jresult = (int)result;
32556   return jresult;
32557 }
32558
32559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32560   int jresult ;
32561   Dali::KeyEvent *arg1 = 0 ;
32562   Dali::Device::Subclass::Type result;
32563
32564   arg1 = (Dali::KeyEvent *)jarg1;
32565   if (!arg1) {
32566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32567     return 0;
32568   }
32569   {
32570     try {
32571       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32572     } catch (std::out_of_range& e) {
32573       {
32574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32575       };
32576     } catch (std::exception& e) {
32577       {
32578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32579       };
32580     } catch (Dali::DaliException e) {
32581       {
32582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32583       };
32584     } catch (...) {
32585       {
32586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32587       };
32588     }
32589   }
32590
32591   jresult = (int)result;
32592   return jresult;
32593 }
32594
32595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32596   Dali::Actor arg1 ;
32597   Dali::Actor *argp1 ;
32598
32599   argp1 = (Dali::Actor *)jarg1;
32600   if (!argp1) {
32601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32602     return ;
32603   }
32604   arg1 = *argp1;
32605   {
32606     try {
32607       arg1.Raise();
32608     } catch (std::out_of_range& e) {
32609       {
32610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32611       };
32612     } catch (std::exception& e) {
32613       {
32614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32615       };
32616     } catch (Dali::DaliException e) {
32617       {
32618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32619       };
32620     } catch (...) {
32621       {
32622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32623       };
32624     }
32625   }
32626
32627 }
32628
32629
32630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32631   Dali::Actor arg1 ;
32632   Dali::Actor *argp1 ;
32633
32634   argp1 = (Dali::Actor *)jarg1;
32635   if (!argp1) {
32636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32637     return ;
32638   }
32639   arg1 = *argp1;
32640   {
32641     try {
32642       arg1.Lower();
32643     } catch (std::out_of_range& e) {
32644       {
32645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32646       };
32647     } catch (std::exception& e) {
32648       {
32649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32650       };
32651     } catch (Dali::DaliException e) {
32652       {
32653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32654       };
32655     } catch (...) {
32656       {
32657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32658       };
32659     }
32660   }
32661
32662 }
32663
32664
32665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32666   Dali::Actor arg1 ;
32667   Dali::Actor *argp1 ;
32668
32669   argp1 = (Dali::Actor *)jarg1;
32670   if (!argp1) {
32671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32672     return ;
32673   }
32674   arg1 = *argp1;
32675   {
32676     try {
32677       arg1.RaiseToTop();
32678     } catch (std::out_of_range& e) {
32679       {
32680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32681       };
32682     } catch (std::exception& e) {
32683       {
32684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32685       };
32686     } catch (Dali::DaliException e) {
32687       {
32688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32689       };
32690     } catch (...) {
32691       {
32692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32693       };
32694     }
32695   }
32696
32697 }
32698
32699
32700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32701   Dali::Actor arg1 ;
32702   Dali::Actor *argp1 ;
32703
32704   argp1 = (Dali::Actor *)jarg1;
32705   if (!argp1) {
32706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32707     return ;
32708   }
32709   arg1 = *argp1;
32710   {
32711     try {
32712       arg1.LowerToBottom();
32713     } catch (std::out_of_range& e) {
32714       {
32715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32716       };
32717     } catch (std::exception& e) {
32718       {
32719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32720       };
32721     } catch (Dali::DaliException e) {
32722       {
32723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32724       };
32725     } catch (...) {
32726       {
32727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32728       };
32729     }
32730   }
32731
32732 }
32733
32734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32735   Dali::Actor arg1 ;
32736   Dali::Actor arg2 ;
32737   Dali::Actor *argp1 ;
32738   Dali::Actor *argp2 ;
32739
32740   argp1 = (Dali::Actor *)jarg1;
32741   if (!argp1) {
32742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32743     return ;
32744   }
32745   arg1 = *argp1;
32746   argp2 = (Dali::Actor *)jarg2;
32747   if (!argp2) {
32748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32749     return ;
32750   }
32751   arg2 = *argp2;
32752   {
32753     try {
32754       arg1.RaiseAbove(arg2);
32755     } catch (std::out_of_range& e) {
32756       {
32757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32758       };
32759     } catch (std::exception& e) {
32760       {
32761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32762       };
32763     } catch (Dali::DaliException e) {
32764       {
32765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32766       };
32767     } catch (...) {
32768       {
32769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32770       };
32771     }
32772   }
32773
32774 }
32775
32776
32777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32778   Dali::Actor arg1 ;
32779   Dali::Actor arg2 ;
32780   Dali::Actor *argp1 ;
32781   Dali::Actor *argp2 ;
32782
32783   argp1 = (Dali::Actor *)jarg1;
32784   if (!argp1) {
32785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32786     return ;
32787   }
32788   arg1 = *argp1;
32789   argp2 = (Dali::Actor *)jarg2;
32790   if (!argp2) {
32791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32792     return ;
32793   }
32794   arg2 = *argp2;
32795   {
32796     try {
32797       arg1.LowerBelow(arg2);
32798     } catch (std::out_of_range& e) {
32799       {
32800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32801       };
32802     } catch (std::exception& e) {
32803       {
32804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32805       };
32806     } catch (Dali::DaliException e) {
32807       {
32808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32809       };
32810     } catch (...) {
32811       {
32812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32813       };
32814     }
32815   }
32816
32817 }
32818
32819
32820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32821   void * jresult ;
32822   Dali::Actor arg1 ;
32823   Dali::Actor *argp1 ;
32824   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32825
32826   argp1 = (Dali::Actor *)jarg1;
32827   if (!argp1) {
32828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32829     return 0;
32830   }
32831   arg1 = *argp1;
32832   {
32833     try {
32834       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32835     } catch (std::out_of_range& e) {
32836       {
32837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32838       };
32839     } catch (std::exception& e) {
32840       {
32841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32842       };
32843     } catch (Dali::DaliException e) {
32844       {
32845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32846       };
32847     } catch (...) {
32848       {
32849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32850       };
32851     }
32852   }
32853
32854   jresult = (void *)result;
32855   return jresult;
32856 }
32857
32858
32859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32860   void * jresult ;
32861   Dali::Actor *arg1 ;
32862   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32863
32864   arg1 = (Dali::Actor *)jarg1;
32865   {
32866     try {
32867       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32868     } catch (std::out_of_range& e) {
32869       {
32870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32871       };
32872     } catch (std::exception& e) {
32873       {
32874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32875       };
32876     } catch (Dali::DaliException e) {
32877       {
32878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32879       };
32880     } catch (...) {
32881       {
32882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32883       };
32884     }
32885   }
32886
32887   jresult = (void *)result;
32888   return jresult;
32889 }
32890
32891
32892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32893   int jresult ;
32894   int result;
32895
32896   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32897   jresult = (int)result;
32898   return jresult;
32899 }
32900
32901
32902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32903   int jresult ;
32904   int result;
32905
32906   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32907   jresult = (int)result;
32908   return jresult;
32909 }
32910
32911
32912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32913   int jresult ;
32914   int result;
32915
32916   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32917   jresult = (int)result;
32918   return jresult;
32919 }
32920
32921
32922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32923   int jresult ;
32924   int result;
32925
32926   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32927   jresult = (int)result;
32928   return jresult;
32929 }
32930
32931
32932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32933   int jresult ;
32934   int result;
32935
32936   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32937   jresult = (int)result;
32938   return jresult;
32939 }
32940
32941
32942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32943   int jresult ;
32944   int result;
32945
32946   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32947   jresult = (int)result;
32948   return jresult;
32949 }
32950
32951
32952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32953   int jresult ;
32954   int result;
32955
32956   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32957   jresult = (int)result;
32958   return jresult;
32959 }
32960
32961
32962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32963   int jresult ;
32964   int result;
32965
32966   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32967   jresult = (int)result;
32968   return jresult;
32969 }
32970
32971
32972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32973   int jresult ;
32974   int result;
32975
32976   result = (int)Dali::Actor::Property::SIZE;
32977   jresult = (int)result;
32978   return jresult;
32979 }
32980
32981
32982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32983   int jresult ;
32984   int result;
32985
32986   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32987   jresult = (int)result;
32988   return jresult;
32989 }
32990
32991
32992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32993   int jresult ;
32994   int result;
32995
32996   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32997   jresult = (int)result;
32998   return jresult;
32999 }
33000
33001
33002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33003   int jresult ;
33004   int result;
33005
33006   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33007   jresult = (int)result;
33008   return jresult;
33009 }
33010
33011
33012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33013   int jresult ;
33014   int result;
33015
33016   result = (int)Dali::Actor::Property::POSITION;
33017   jresult = (int)result;
33018   return jresult;
33019 }
33020
33021
33022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33023   int jresult ;
33024   int result;
33025
33026   result = (int)Dali::Actor::Property::POSITION_X;
33027   jresult = (int)result;
33028   return jresult;
33029 }
33030
33031
33032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33033   int jresult ;
33034   int result;
33035
33036   result = (int)Dali::Actor::Property::POSITION_Y;
33037   jresult = (int)result;
33038   return jresult;
33039 }
33040
33041
33042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33043   int jresult ;
33044   int result;
33045
33046   result = (int)Dali::Actor::Property::POSITION_Z;
33047   jresult = (int)result;
33048   return jresult;
33049 }
33050
33051
33052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33053   int jresult ;
33054   int result;
33055
33056   result = (int)Dali::Actor::Property::WORLD_POSITION;
33057   jresult = (int)result;
33058   return jresult;
33059 }
33060
33061
33062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33063   int jresult ;
33064   int result;
33065
33066   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33067   jresult = (int)result;
33068   return jresult;
33069 }
33070
33071
33072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33073   int jresult ;
33074   int result;
33075
33076   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33077   jresult = (int)result;
33078   return jresult;
33079 }
33080
33081
33082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33083   int jresult ;
33084   int result;
33085
33086   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33087   jresult = (int)result;
33088   return jresult;
33089 }
33090
33091
33092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33093   int jresult ;
33094   int result;
33095
33096   result = (int)Dali::Actor::Property::ORIENTATION;
33097   jresult = (int)result;
33098   return jresult;
33099 }
33100
33101
33102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33103   int jresult ;
33104   int result;
33105
33106   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33107   jresult = (int)result;
33108   return jresult;
33109 }
33110
33111
33112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33113   int jresult ;
33114   int result;
33115
33116   result = (int)Dali::Actor::Property::SCALE;
33117   jresult = (int)result;
33118   return jresult;
33119 }
33120
33121
33122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33123   int jresult ;
33124   int result;
33125
33126   result = (int)Dali::Actor::Property::SCALE_X;
33127   jresult = (int)result;
33128   return jresult;
33129 }
33130
33131
33132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33133   int jresult ;
33134   int result;
33135
33136   result = (int)Dali::Actor::Property::SCALE_Y;
33137   jresult = (int)result;
33138   return jresult;
33139 }
33140
33141
33142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33143   int jresult ;
33144   int result;
33145
33146   result = (int)Dali::Actor::Property::SCALE_Z;
33147   jresult = (int)result;
33148   return jresult;
33149 }
33150
33151
33152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33153   int jresult ;
33154   int result;
33155
33156   result = (int)Dali::Actor::Property::WORLD_SCALE;
33157   jresult = (int)result;
33158   return jresult;
33159 }
33160
33161
33162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33163   int jresult ;
33164   int result;
33165
33166   result = (int)Dali::Actor::Property::VISIBLE;
33167   jresult = (int)result;
33168   return jresult;
33169 }
33170
33171
33172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33173   int jresult ;
33174   int result;
33175
33176   result = (int)Dali::Actor::Property::COLOR;
33177   jresult = (int)result;
33178   return jresult;
33179 }
33180
33181
33182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33183   int jresult ;
33184   int result;
33185
33186   result = (int)Dali::Actor::Property::COLOR_RED;
33187   jresult = (int)result;
33188   return jresult;
33189 }
33190
33191
33192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33193   int jresult ;
33194   int result;
33195
33196   result = (int)Dali::Actor::Property::COLOR_GREEN;
33197   jresult = (int)result;
33198   return jresult;
33199 }
33200
33201
33202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33203   int jresult ;
33204   int result;
33205
33206   result = (int)Dali::Actor::Property::COLOR_BLUE;
33207   jresult = (int)result;
33208   return jresult;
33209 }
33210
33211
33212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33213   int jresult ;
33214   int result;
33215
33216   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33217   jresult = (int)result;
33218   return jresult;
33219 }
33220
33221
33222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33223   int jresult ;
33224   int result;
33225
33226   result = (int)Dali::Actor::Property::WORLD_COLOR;
33227   jresult = (int)result;
33228   return jresult;
33229 }
33230
33231
33232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33233   int jresult ;
33234   int result;
33235
33236   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33237   jresult = (int)result;
33238   return jresult;
33239 }
33240
33241
33242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33243   int jresult ;
33244   int result;
33245
33246   result = (int)Dali::Actor::Property::NAME;
33247   jresult = (int)result;
33248   return jresult;
33249 }
33250
33251
33252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33253   int jresult ;
33254   int result;
33255
33256   result = (int)Dali::Actor::Property::SENSITIVE;
33257   jresult = (int)result;
33258   return jresult;
33259 }
33260
33261
33262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33263   int jresult ;
33264   int result;
33265
33266   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33267   jresult = (int)result;
33268   return jresult;
33269 }
33270
33271
33272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33273   int jresult ;
33274   int result;
33275
33276   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33277   jresult = (int)result;
33278   return jresult;
33279 }
33280
33281
33282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33283   int jresult ;
33284   int result;
33285
33286   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33287   jresult = (int)result;
33288   return jresult;
33289 }
33290
33291
33292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33293   int jresult ;
33294   int result;
33295
33296   result = (int)Dali::Actor::Property::COLOR_MODE;
33297   jresult = (int)result;
33298   return jresult;
33299 }
33300
33301
33302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33303   int jresult ;
33304   int result;
33305
33306   result = (int)Dali::Actor::Property::DRAW_MODE;
33307   jresult = (int)result;
33308   return jresult;
33309 }
33310
33311
33312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33313   int jresult ;
33314   int result;
33315
33316   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33317   jresult = (int)result;
33318   return jresult;
33319 }
33320
33321
33322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33323   int jresult ;
33324   int result;
33325
33326   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33327   jresult = (int)result;
33328   return jresult;
33329 }
33330
33331
33332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33333   int jresult ;
33334   int result;
33335
33336   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33337   jresult = (int)result;
33338   return jresult;
33339 }
33340
33341
33342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33343   int jresult ;
33344   int result;
33345
33346   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33347   jresult = (int)result;
33348   return jresult;
33349 }
33350
33351
33352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33353   int jresult ;
33354   int result;
33355
33356   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33357   jresult = (int)result;
33358   return jresult;
33359 }
33360
33361
33362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33363   int jresult ;
33364   int result;
33365
33366   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33367   jresult = (int)result;
33368   return jresult;
33369 }
33370
33371
33372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33373   int jresult ;
33374   int result;
33375
33376   result = (int)Dali::Actor::Property::PADDING;
33377   jresult = (int)result;
33378   return jresult;
33379 }
33380
33381
33382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33383   int jresult ;
33384   int result;
33385
33386   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33387   jresult = (int)result;
33388   return jresult;
33389 }
33390
33391
33392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33393   int jresult ;
33394   int result;
33395
33396   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33397   jresult = (int)result;
33398   return jresult;
33399 }
33400
33401
33402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33403   int jresult ;
33404   int result;
33405
33406   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33407   jresult = (int)result;
33408   return jresult;
33409 }
33410
33411
33412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33413   int jresult ;
33414   int result;
33415
33416   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33417   jresult = (int)result;
33418   return jresult;
33419 }
33420
33421
33422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33423   void * jresult ;
33424   Dali::Actor::Property *result = 0 ;
33425
33426   {
33427     try {
33428       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33429     } catch (std::out_of_range& e) {
33430       {
33431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33432       };
33433     } catch (std::exception& e) {
33434       {
33435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33436       };
33437     } catch (Dali::DaliException e) {
33438       {
33439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33440       };
33441     } catch (...) {
33442       {
33443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33444       };
33445     }
33446   }
33447
33448   jresult = (void *)result;
33449   return jresult;
33450 }
33451
33452
33453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33454   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33455
33456   arg1 = (Dali::Actor::Property *)jarg1;
33457   {
33458     try {
33459       delete arg1;
33460     } catch (std::out_of_range& e) {
33461       {
33462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33463       };
33464     } catch (std::exception& e) {
33465       {
33466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33467       };
33468     } catch (Dali::DaliException e) {
33469       {
33470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33471       };
33472     } catch (...) {
33473       {
33474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33475       };
33476     }
33477   }
33478
33479 }
33480
33481
33482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33483   void * jresult ;
33484   Dali::Actor *result = 0 ;
33485
33486   {
33487     try {
33488       result = (Dali::Actor *)new Dali::Actor();
33489     } catch (std::out_of_range& e) {
33490       {
33491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33492       };
33493     } catch (std::exception& e) {
33494       {
33495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33496       };
33497     } catch (Dali::DaliException e) {
33498       {
33499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33500       };
33501     } catch (...) {
33502       {
33503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33504       };
33505     }
33506   }
33507
33508   jresult = (void *)result;
33509   return jresult;
33510 }
33511
33512
33513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33514   void * jresult ;
33515   Dali::Actor result;
33516
33517   {
33518     try {
33519       result = Dali::Actor::New();
33520     } catch (std::out_of_range& e) {
33521       {
33522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33523       };
33524     } catch (std::exception& e) {
33525       {
33526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33527       };
33528     } catch (Dali::DaliException e) {
33529       {
33530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33531       };
33532     } catch (...) {
33533       {
33534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33535       };
33536     }
33537   }
33538
33539   jresult = new Dali::Actor((const Dali::Actor &)result);
33540   return jresult;
33541 }
33542
33543
33544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33545   void * jresult ;
33546   Dali::BaseHandle arg1 ;
33547   Dali::BaseHandle *argp1 ;
33548   Dali::Actor result;
33549
33550   argp1 = (Dali::BaseHandle *)jarg1;
33551   if (!argp1) {
33552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33553     return 0;
33554   }
33555   arg1 = *argp1;
33556   {
33557     try {
33558       result = Dali::Actor::DownCast(arg1);
33559     } catch (std::out_of_range& e) {
33560       {
33561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33562       };
33563     } catch (std::exception& e) {
33564       {
33565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33566       };
33567     } catch (Dali::DaliException e) {
33568       {
33569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33570       };
33571     } catch (...) {
33572       {
33573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33574       };
33575     }
33576   }
33577
33578   jresult = new Dali::Actor((const Dali::Actor &)result);
33579   return jresult;
33580 }
33581
33582
33583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33584   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33585
33586   arg1 = (Dali::Actor *)jarg1;
33587   {
33588     try {
33589       delete arg1;
33590     } catch (std::out_of_range& e) {
33591       {
33592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33593       };
33594     } catch (std::exception& e) {
33595       {
33596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33597       };
33598     } catch (Dali::DaliException e) {
33599       {
33600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33601       };
33602     } catch (...) {
33603       {
33604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33605       };
33606     }
33607   }
33608
33609 }
33610
33611
33612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33613   void * jresult ;
33614   Dali::Actor *arg1 = 0 ;
33615   Dali::Actor *result = 0 ;
33616
33617   arg1 = (Dali::Actor *)jarg1;
33618   if (!arg1) {
33619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33620     return 0;
33621   }
33622   {
33623     try {
33624       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33625     } catch (std::out_of_range& e) {
33626       {
33627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33628       };
33629     } catch (std::exception& e) {
33630       {
33631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33632       };
33633     } catch (Dali::DaliException e) {
33634       {
33635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33636       };
33637     } catch (...) {
33638       {
33639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33640       };
33641     }
33642   }
33643
33644   jresult = (void *)result;
33645   return jresult;
33646 }
33647
33648
33649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33650   void * jresult ;
33651   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33652   Dali::Actor *arg2 = 0 ;
33653   Dali::Actor *result = 0 ;
33654
33655   arg1 = (Dali::Actor *)jarg1;
33656   arg2 = (Dali::Actor *)jarg2;
33657   if (!arg2) {
33658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33659     return 0;
33660   }
33661   {
33662     try {
33663       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33664     } catch (std::out_of_range& e) {
33665       {
33666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33667       };
33668     } catch (std::exception& e) {
33669       {
33670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33671       };
33672     } catch (Dali::DaliException e) {
33673       {
33674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33675       };
33676     } catch (...) {
33677       {
33678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33679       };
33680     }
33681   }
33682
33683   jresult = (void *)result;
33684   return jresult;
33685 }
33686
33687
33688 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33689   char * jresult ;
33690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33691   std::string *result = 0 ;
33692
33693   arg1 = (Dali::Actor *)jarg1;
33694   {
33695     try {
33696       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33697     } catch (std::out_of_range& e) {
33698       {
33699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33700       };
33701     } catch (std::exception& e) {
33702       {
33703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33704       };
33705     } catch (Dali::DaliException e) {
33706       {
33707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33708       };
33709     } catch (...) {
33710       {
33711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33712       };
33713     }
33714   }
33715
33716   jresult = SWIG_csharp_string_callback(result->c_str());
33717   return jresult;
33718 }
33719
33720
33721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33722   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33723   std::string *arg2 = 0 ;
33724
33725   arg1 = (Dali::Actor *)jarg1;
33726   if (!jarg2) {
33727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33728     return ;
33729   }
33730   std::string arg2_str(jarg2);
33731   arg2 = &arg2_str;
33732   {
33733     try {
33734       (arg1)->SetName((std::string const &)*arg2);
33735     } catch (std::out_of_range& e) {
33736       {
33737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33738       };
33739     } catch (std::exception& e) {
33740       {
33741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33742       };
33743     } catch (Dali::DaliException e) {
33744       {
33745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33746       };
33747     } catch (...) {
33748       {
33749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33750       };
33751     }
33752   }
33753
33754
33755   //argout typemap for const std::string&
33756
33757 }
33758
33759
33760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33761   unsigned int jresult ;
33762   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33763   unsigned int result;
33764
33765   arg1 = (Dali::Actor *)jarg1;
33766   {
33767     try {
33768       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33769     } catch (std::out_of_range& e) {
33770       {
33771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33772       };
33773     } catch (std::exception& e) {
33774       {
33775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33776       };
33777     } catch (Dali::DaliException e) {
33778       {
33779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33780       };
33781     } catch (...) {
33782       {
33783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33784       };
33785     }
33786   }
33787
33788   jresult = result;
33789   return jresult;
33790 }
33791
33792
33793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33794   unsigned int jresult ;
33795   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33796   bool result;
33797
33798   arg1 = (Dali::Actor *)jarg1;
33799   {
33800     try {
33801       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33802     } catch (std::out_of_range& e) {
33803       {
33804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33805       };
33806     } catch (std::exception& e) {
33807       {
33808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33809       };
33810     } catch (Dali::DaliException e) {
33811       {
33812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33813       };
33814     } catch (...) {
33815       {
33816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33817       };
33818     }
33819   }
33820
33821   jresult = result;
33822   return jresult;
33823 }
33824
33825
33826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33827   unsigned int jresult ;
33828   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33829   bool result;
33830
33831   arg1 = (Dali::Actor *)jarg1;
33832   {
33833     try {
33834       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33835     } catch (std::out_of_range& e) {
33836       {
33837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33838       };
33839     } catch (std::exception& e) {
33840       {
33841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33842       };
33843     } catch (Dali::DaliException e) {
33844       {
33845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33846       };
33847     } catch (...) {
33848       {
33849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33850       };
33851     }
33852   }
33853
33854   jresult = result;
33855   return jresult;
33856 }
33857
33858
33859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33860   unsigned int jresult ;
33861   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33862   bool result;
33863
33864   arg1 = (Dali::Actor *)jarg1;
33865   {
33866     try {
33867       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33868     } catch (std::out_of_range& e) {
33869       {
33870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33871       };
33872     } catch (std::exception& e) {
33873       {
33874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33875       };
33876     } catch (Dali::DaliException e) {
33877       {
33878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33879       };
33880     } catch (...) {
33881       {
33882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33883       };
33884     }
33885   }
33886
33887   jresult = result;
33888   return jresult;
33889 }
33890
33891
33892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33893   void * jresult ;
33894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33895   Dali::Layer result;
33896
33897   arg1 = (Dali::Actor *)jarg1;
33898   {
33899     try {
33900       result = (arg1)->GetLayer();
33901     } catch (std::out_of_range& e) {
33902       {
33903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33904       };
33905     } catch (std::exception& e) {
33906       {
33907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33908       };
33909     } catch (Dali::DaliException e) {
33910       {
33911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33912       };
33913     } catch (...) {
33914       {
33915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33916       };
33917     }
33918   }
33919
33920   jresult = new Dali::Layer((const Dali::Layer &)result);
33921   return jresult;
33922 }
33923
33924
33925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33926   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33927   Dali::Actor arg2 ;
33928   Dali::Actor *argp2 ;
33929
33930   arg1 = (Dali::Actor *)jarg1;
33931   argp2 = (Dali::Actor *)jarg2;
33932   if (!argp2) {
33933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33934     return ;
33935   }
33936   arg2 = *argp2;
33937   {
33938     try {
33939       (arg1)->Add(arg2);
33940     } catch (std::out_of_range& e) {
33941       {
33942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33943       };
33944     } catch (std::exception& e) {
33945       {
33946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33947       };
33948     } catch (Dali::DaliException e) {
33949       {
33950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33951       };
33952     } catch (...) {
33953       {
33954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33955       };
33956     }
33957   }
33958
33959 }
33960
33961
33962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33963   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33964   Dali::Actor arg2 ;
33965   Dali::Actor *argp2 ;
33966
33967   arg1 = (Dali::Actor *)jarg1;
33968   argp2 = (Dali::Actor *)jarg2;
33969   if (!argp2) {
33970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33971     return ;
33972   }
33973   arg2 = *argp2;
33974   {
33975     try {
33976       (arg1)->Remove(arg2);
33977     } catch (std::out_of_range& e) {
33978       {
33979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33980       };
33981     } catch (std::exception& e) {
33982       {
33983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33984       };
33985     } catch (Dali::DaliException e) {
33986       {
33987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33988       };
33989     } catch (...) {
33990       {
33991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33992       };
33993     }
33994   }
33995
33996 }
33997
33998
33999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34000   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34001
34002   arg1 = (Dali::Actor *)jarg1;
34003   {
34004     try {
34005       (arg1)->Unparent();
34006     } catch (std::out_of_range& e) {
34007       {
34008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34009       };
34010     } catch (std::exception& e) {
34011       {
34012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34013       };
34014     } catch (Dali::DaliException e) {
34015       {
34016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34017       };
34018     } catch (...) {
34019       {
34020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34021       };
34022     }
34023   }
34024
34025 }
34026
34027
34028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34029   unsigned int jresult ;
34030   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34031   unsigned int result;
34032
34033   arg1 = (Dali::Actor *)jarg1;
34034   {
34035     try {
34036       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34037     } catch (std::out_of_range& e) {
34038       {
34039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34040       };
34041     } catch (std::exception& e) {
34042       {
34043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34044       };
34045     } catch (Dali::DaliException e) {
34046       {
34047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34048       };
34049     } catch (...) {
34050       {
34051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34052       };
34053     }
34054   }
34055
34056   jresult = result;
34057   return jresult;
34058 }
34059
34060
34061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34062   void * jresult ;
34063   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34064   unsigned int arg2 ;
34065   Dali::Actor result;
34066
34067   arg1 = (Dali::Actor *)jarg1;
34068   arg2 = (unsigned int)jarg2;
34069   {
34070     try {
34071       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34072     } catch (std::out_of_range& e) {
34073       {
34074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34075       };
34076     } catch (std::exception& e) {
34077       {
34078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34079       };
34080     } catch (Dali::DaliException e) {
34081       {
34082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34083       };
34084     } catch (...) {
34085       {
34086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34087       };
34088     }
34089   }
34090
34091   jresult = new Dali::Actor((const Dali::Actor &)result);
34092   return jresult;
34093 }
34094
34095
34096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34097   void * jresult ;
34098   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34099   std::string *arg2 = 0 ;
34100   Dali::Actor result;
34101
34102   arg1 = (Dali::Actor *)jarg1;
34103   if (!jarg2) {
34104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34105     return 0;
34106   }
34107   std::string arg2_str(jarg2);
34108   arg2 = &arg2_str;
34109   {
34110     try {
34111       result = (arg1)->FindChildByName((std::string const &)*arg2);
34112     } catch (std::out_of_range& e) {
34113       {
34114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34115       };
34116     } catch (std::exception& e) {
34117       {
34118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34119       };
34120     } catch (Dali::DaliException e) {
34121       {
34122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34123       };
34124     } catch (...) {
34125       {
34126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34127       };
34128     }
34129   }
34130
34131   jresult = new Dali::Actor((const Dali::Actor &)result);
34132
34133   //argout typemap for const std::string&
34134
34135   return jresult;
34136 }
34137
34138
34139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34140   void * jresult ;
34141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34142   unsigned int arg2 ;
34143   Dali::Actor result;
34144
34145   arg1 = (Dali::Actor *)jarg1;
34146   arg2 = (unsigned int)jarg2;
34147   {
34148     try {
34149       result = (arg1)->FindChildById(arg2);
34150     } catch (std::out_of_range& e) {
34151       {
34152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34153       };
34154     } catch (std::exception& e) {
34155       {
34156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34157       };
34158     } catch (Dali::DaliException e) {
34159       {
34160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34161       };
34162     } catch (...) {
34163       {
34164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34165       };
34166     }
34167   }
34168
34169   jresult = new Dali::Actor((const Dali::Actor &)result);
34170   return jresult;
34171 }
34172
34173
34174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34175   void * jresult ;
34176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34177   Dali::Actor result;
34178
34179   arg1 = (Dali::Actor *)jarg1;
34180   {
34181     try {
34182       result = ((Dali::Actor const *)arg1)->GetParent();
34183     } catch (std::out_of_range& e) {
34184       {
34185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34186       };
34187     } catch (std::exception& e) {
34188       {
34189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34190       };
34191     } catch (Dali::DaliException e) {
34192       {
34193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34194       };
34195     } catch (...) {
34196       {
34197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34198       };
34199     }
34200   }
34201
34202   jresult = new Dali::Actor((const Dali::Actor &)result);
34203   return jresult;
34204 }
34205
34206
34207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34208   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34209   Dali::Vector3 *arg2 = 0 ;
34210
34211   arg1 = (Dali::Actor *)jarg1;
34212   arg2 = (Dali::Vector3 *)jarg2;
34213   if (!arg2) {
34214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34215     return ;
34216   }
34217   {
34218     try {
34219       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34220     } catch (std::out_of_range& e) {
34221       {
34222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34223       };
34224     } catch (std::exception& e) {
34225       {
34226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34227       };
34228     } catch (Dali::DaliException e) {
34229       {
34230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34231       };
34232     } catch (...) {
34233       {
34234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34235       };
34236     }
34237   }
34238
34239 }
34240
34241
34242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34243   void * jresult ;
34244   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34245   Dali::Vector3 result;
34246
34247   arg1 = (Dali::Actor *)jarg1;
34248   {
34249     try {
34250       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34251     } catch (std::out_of_range& e) {
34252       {
34253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34254       };
34255     } catch (std::exception& e) {
34256       {
34257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34258       };
34259     } catch (Dali::DaliException e) {
34260       {
34261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34262       };
34263     } catch (...) {
34264       {
34265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34266       };
34267     }
34268   }
34269
34270   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34271   return jresult;
34272 }
34273
34274
34275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34276   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34277   Dali::Vector3 *arg2 = 0 ;
34278
34279   arg1 = (Dali::Actor *)jarg1;
34280   arg2 = (Dali::Vector3 *)jarg2;
34281   if (!arg2) {
34282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34283     return ;
34284   }
34285   {
34286     try {
34287       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34288     } catch (std::out_of_range& e) {
34289       {
34290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34291       };
34292     } catch (std::exception& e) {
34293       {
34294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34295       };
34296     } catch (Dali::DaliException e) {
34297       {
34298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34299       };
34300     } catch (...) {
34301       {
34302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34303       };
34304     }
34305   }
34306
34307 }
34308
34309
34310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34311   void * jresult ;
34312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34313   Dali::Vector3 result;
34314
34315   arg1 = (Dali::Actor *)jarg1;
34316   {
34317     try {
34318       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34319     } catch (std::out_of_range& e) {
34320       {
34321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34322       };
34323     } catch (std::exception& e) {
34324       {
34325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34326       };
34327     } catch (Dali::DaliException e) {
34328       {
34329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34330       };
34331     } catch (...) {
34332       {
34333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34334       };
34335     }
34336   }
34337
34338   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34339   return jresult;
34340 }
34341
34342
34343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34344   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34345   float arg2 ;
34346   float arg3 ;
34347
34348   arg1 = (Dali::Actor *)jarg1;
34349   arg2 = (float)jarg2;
34350   arg3 = (float)jarg3;
34351   {
34352     try {
34353       (arg1)->SetSize(arg2,arg3);
34354     } catch (std::out_of_range& e) {
34355       {
34356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34357       };
34358     } catch (std::exception& e) {
34359       {
34360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34361       };
34362     } catch (Dali::DaliException e) {
34363       {
34364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34365       };
34366     } catch (...) {
34367       {
34368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34369       };
34370     }
34371   }
34372
34373 }
34374
34375
34376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34377   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34378   float arg2 ;
34379   float arg3 ;
34380   float arg4 ;
34381
34382   arg1 = (Dali::Actor *)jarg1;
34383   arg2 = (float)jarg2;
34384   arg3 = (float)jarg3;
34385   arg4 = (float)jarg4;
34386   {
34387     try {
34388       (arg1)->SetSize(arg2,arg3,arg4);
34389     } catch (std::out_of_range& e) {
34390       {
34391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34392       };
34393     } catch (std::exception& e) {
34394       {
34395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34396       };
34397     } catch (Dali::DaliException e) {
34398       {
34399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34400       };
34401     } catch (...) {
34402       {
34403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34404       };
34405     }
34406   }
34407
34408 }
34409
34410
34411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34412   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34413   Dali::Vector2 *arg2 = 0 ;
34414
34415   arg1 = (Dali::Actor *)jarg1;
34416   arg2 = (Dali::Vector2 *)jarg2;
34417   if (!arg2) {
34418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34419     return ;
34420   }
34421   {
34422     try {
34423       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34424     } catch (std::out_of_range& e) {
34425       {
34426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34427       };
34428     } catch (std::exception& e) {
34429       {
34430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34431       };
34432     } catch (Dali::DaliException e) {
34433       {
34434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34435       };
34436     } catch (...) {
34437       {
34438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34439       };
34440     }
34441   }
34442
34443 }
34444
34445
34446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34447   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34448   Dali::Vector3 *arg2 = 0 ;
34449
34450   arg1 = (Dali::Actor *)jarg1;
34451   arg2 = (Dali::Vector3 *)jarg2;
34452   if (!arg2) {
34453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34454     return ;
34455   }
34456   {
34457     try {
34458       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34459     } catch (std::out_of_range& e) {
34460       {
34461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34462       };
34463     } catch (std::exception& e) {
34464       {
34465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34466       };
34467     } catch (Dali::DaliException e) {
34468       {
34469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34470       };
34471     } catch (...) {
34472       {
34473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34474       };
34475     }
34476   }
34477
34478 }
34479
34480
34481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34482   void * jresult ;
34483   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34484   Dali::Vector3 result;
34485
34486   arg1 = (Dali::Actor *)jarg1;
34487   {
34488     try {
34489       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34490     } catch (std::out_of_range& e) {
34491       {
34492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34493       };
34494     } catch (std::exception& e) {
34495       {
34496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34497       };
34498     } catch (Dali::DaliException e) {
34499       {
34500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34501       };
34502     } catch (...) {
34503       {
34504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34505       };
34506     }
34507   }
34508
34509   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34510   return jresult;
34511 }
34512
34513
34514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34515   void * jresult ;
34516   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34517   Dali::Vector3 result;
34518
34519   arg1 = (Dali::Actor *)jarg1;
34520   {
34521     try {
34522       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34523     } catch (std::out_of_range& e) {
34524       {
34525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34526       };
34527     } catch (std::exception& e) {
34528       {
34529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34530       };
34531     } catch (Dali::DaliException e) {
34532       {
34533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34534       };
34535     } catch (...) {
34536       {
34537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34538       };
34539     }
34540   }
34541
34542   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34543   return jresult;
34544 }
34545
34546
34547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34548   void * jresult ;
34549   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34550   Dali::Vector3 result;
34551
34552   arg1 = (Dali::Actor *)jarg1;
34553   {
34554     try {
34555       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34556     } catch (std::out_of_range& e) {
34557       {
34558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34559       };
34560     } catch (std::exception& e) {
34561       {
34562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34563       };
34564     } catch (Dali::DaliException e) {
34565       {
34566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34567       };
34568     } catch (...) {
34569       {
34570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34571       };
34572     }
34573   }
34574
34575   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34576   return jresult;
34577 }
34578
34579
34580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34581   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34582   float arg2 ;
34583   float arg3 ;
34584
34585   arg1 = (Dali::Actor *)jarg1;
34586   arg2 = (float)jarg2;
34587   arg3 = (float)jarg3;
34588   {
34589     try {
34590       (arg1)->SetPosition(arg2,arg3);
34591     } catch (std::out_of_range& e) {
34592       {
34593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34594       };
34595     } catch (std::exception& e) {
34596       {
34597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34598       };
34599     } catch (Dali::DaliException e) {
34600       {
34601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34602       };
34603     } catch (...) {
34604       {
34605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34606       };
34607     }
34608   }
34609
34610 }
34611
34612
34613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34615   float arg2 ;
34616   float arg3 ;
34617   float arg4 ;
34618
34619   arg1 = (Dali::Actor *)jarg1;
34620   arg2 = (float)jarg2;
34621   arg3 = (float)jarg3;
34622   arg4 = (float)jarg4;
34623   {
34624     try {
34625       (arg1)->SetPosition(arg2,arg3,arg4);
34626     } catch (std::out_of_range& e) {
34627       {
34628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34629       };
34630     } catch (std::exception& e) {
34631       {
34632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34633       };
34634     } catch (Dali::DaliException e) {
34635       {
34636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34637       };
34638     } catch (...) {
34639       {
34640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34641       };
34642     }
34643   }
34644
34645 }
34646
34647
34648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34649   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34650   Dali::Vector3 *arg2 = 0 ;
34651
34652   arg1 = (Dali::Actor *)jarg1;
34653   arg2 = (Dali::Vector3 *)jarg2;
34654   if (!arg2) {
34655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34656     return ;
34657   }
34658   {
34659     try {
34660       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34661     } catch (std::out_of_range& e) {
34662       {
34663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34664       };
34665     } catch (std::exception& e) {
34666       {
34667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34668       };
34669     } catch (Dali::DaliException e) {
34670       {
34671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34672       };
34673     } catch (...) {
34674       {
34675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34676       };
34677     }
34678   }
34679
34680 }
34681
34682
34683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34685   float arg2 ;
34686
34687   arg1 = (Dali::Actor *)jarg1;
34688   arg2 = (float)jarg2;
34689   {
34690     try {
34691       (arg1)->SetX(arg2);
34692     } catch (std::out_of_range& e) {
34693       {
34694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34695       };
34696     } catch (std::exception& e) {
34697       {
34698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34699       };
34700     } catch (Dali::DaliException e) {
34701       {
34702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34703       };
34704     } catch (...) {
34705       {
34706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34707       };
34708     }
34709   }
34710
34711 }
34712
34713
34714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34715   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34716   float arg2 ;
34717
34718   arg1 = (Dali::Actor *)jarg1;
34719   arg2 = (float)jarg2;
34720   {
34721     try {
34722       (arg1)->SetY(arg2);
34723     } catch (std::out_of_range& e) {
34724       {
34725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34726       };
34727     } catch (std::exception& e) {
34728       {
34729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34730       };
34731     } catch (Dali::DaliException e) {
34732       {
34733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34734       };
34735     } catch (...) {
34736       {
34737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34738       };
34739     }
34740   }
34741
34742 }
34743
34744
34745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34746   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34747   float arg2 ;
34748
34749   arg1 = (Dali::Actor *)jarg1;
34750   arg2 = (float)jarg2;
34751   {
34752     try {
34753       (arg1)->SetZ(arg2);
34754     } catch (std::out_of_range& e) {
34755       {
34756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34757       };
34758     } catch (std::exception& e) {
34759       {
34760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34761       };
34762     } catch (Dali::DaliException e) {
34763       {
34764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34765       };
34766     } catch (...) {
34767       {
34768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34769       };
34770     }
34771   }
34772
34773 }
34774
34775
34776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34777   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34778   Dali::Vector3 *arg2 = 0 ;
34779
34780   arg1 = (Dali::Actor *)jarg1;
34781   arg2 = (Dali::Vector3 *)jarg2;
34782   if (!arg2) {
34783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34784     return ;
34785   }
34786   {
34787     try {
34788       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34789     } catch (std::out_of_range& e) {
34790       {
34791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34792       };
34793     } catch (std::exception& e) {
34794       {
34795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34796       };
34797     } catch (Dali::DaliException e) {
34798       {
34799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34800       };
34801     } catch (...) {
34802       {
34803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34804       };
34805     }
34806   }
34807
34808 }
34809
34810
34811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34812   void * jresult ;
34813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34814   Dali::Vector3 result;
34815
34816   arg1 = (Dali::Actor *)jarg1;
34817   {
34818     try {
34819       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34820     } catch (std::out_of_range& e) {
34821       {
34822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34823       };
34824     } catch (std::exception& e) {
34825       {
34826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34827       };
34828     } catch (Dali::DaliException e) {
34829       {
34830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34831       };
34832     } catch (...) {
34833       {
34834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34835       };
34836     }
34837   }
34838
34839   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34840   return jresult;
34841 }
34842
34843
34844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34845   void * jresult ;
34846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34847   Dali::Vector3 result;
34848
34849   arg1 = (Dali::Actor *)jarg1;
34850   {
34851     try {
34852       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34853     } catch (std::out_of_range& e) {
34854       {
34855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34856       };
34857     } catch (std::exception& e) {
34858       {
34859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34860       };
34861     } catch (Dali::DaliException e) {
34862       {
34863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34864       };
34865     } catch (...) {
34866       {
34867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34868       };
34869     }
34870   }
34871
34872   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34873   return jresult;
34874 }
34875
34876
34877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34879   bool arg2 ;
34880
34881   arg1 = (Dali::Actor *)jarg1;
34882   arg2 = jarg2 ? true : false;
34883   {
34884     try {
34885       (arg1)->SetInheritPosition(arg2);
34886     } catch (std::out_of_range& e) {
34887       {
34888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34889       };
34890     } catch (std::exception& e) {
34891       {
34892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34893       };
34894     } catch (Dali::DaliException e) {
34895       {
34896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34897       };
34898     } catch (...) {
34899       {
34900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34901       };
34902     }
34903   }
34904
34905 }
34906
34907
34908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34909   unsigned int jresult ;
34910   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34911   bool result;
34912
34913   arg1 = (Dali::Actor *)jarg1;
34914   {
34915     try {
34916       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34917     } catch (std::out_of_range& e) {
34918       {
34919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34920       };
34921     } catch (std::exception& e) {
34922       {
34923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34924       };
34925     } catch (Dali::DaliException e) {
34926       {
34927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34928       };
34929     } catch (...) {
34930       {
34931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34932       };
34933     }
34934   }
34935
34936   jresult = result;
34937   return jresult;
34938 }
34939
34940
34941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34942   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34943   Dali::Degree *arg2 = 0 ;
34944   Dali::Vector3 *arg3 = 0 ;
34945
34946   arg1 = (Dali::Actor *)jarg1;
34947   arg2 = (Dali::Degree *)jarg2;
34948   if (!arg2) {
34949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34950     return ;
34951   }
34952   arg3 = (Dali::Vector3 *)jarg3;
34953   if (!arg3) {
34954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34955     return ;
34956   }
34957   {
34958     try {
34959       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34960     } catch (std::out_of_range& e) {
34961       {
34962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34963       };
34964     } catch (std::exception& e) {
34965       {
34966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34967       };
34968     } catch (Dali::DaliException e) {
34969       {
34970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34971       };
34972     } catch (...) {
34973       {
34974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34975       };
34976     }
34977   }
34978
34979 }
34980
34981
34982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34984   Dali::Radian *arg2 = 0 ;
34985   Dali::Vector3 *arg3 = 0 ;
34986
34987   arg1 = (Dali::Actor *)jarg1;
34988   arg2 = (Dali::Radian *)jarg2;
34989   if (!arg2) {
34990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34991     return ;
34992   }
34993   arg3 = (Dali::Vector3 *)jarg3;
34994   if (!arg3) {
34995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34996     return ;
34997   }
34998   {
34999     try {
35000       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35001     } catch (std::out_of_range& e) {
35002       {
35003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35004       };
35005     } catch (std::exception& e) {
35006       {
35007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35008       };
35009     } catch (Dali::DaliException e) {
35010       {
35011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35012       };
35013     } catch (...) {
35014       {
35015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35016       };
35017     }
35018   }
35019
35020 }
35021
35022
35023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35024   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35025   Dali::Quaternion *arg2 = 0 ;
35026
35027   arg1 = (Dali::Actor *)jarg1;
35028   arg2 = (Dali::Quaternion *)jarg2;
35029   if (!arg2) {
35030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35031     return ;
35032   }
35033   {
35034     try {
35035       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35036     } catch (std::out_of_range& e) {
35037       {
35038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35039       };
35040     } catch (std::exception& e) {
35041       {
35042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35043       };
35044     } catch (Dali::DaliException e) {
35045       {
35046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35047       };
35048     } catch (...) {
35049       {
35050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35051       };
35052     }
35053   }
35054
35055 }
35056
35057
35058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35059   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35060   Dali::Degree *arg2 = 0 ;
35061   Dali::Vector3 *arg3 = 0 ;
35062
35063   arg1 = (Dali::Actor *)jarg1;
35064   arg2 = (Dali::Degree *)jarg2;
35065   if (!arg2) {
35066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35067     return ;
35068   }
35069   arg3 = (Dali::Vector3 *)jarg3;
35070   if (!arg3) {
35071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35072     return ;
35073   }
35074   {
35075     try {
35076       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35077     } catch (std::out_of_range& e) {
35078       {
35079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35080       };
35081     } catch (std::exception& e) {
35082       {
35083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35084       };
35085     } catch (Dali::DaliException e) {
35086       {
35087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35088       };
35089     } catch (...) {
35090       {
35091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35092       };
35093     }
35094   }
35095
35096 }
35097
35098
35099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35100   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35101   Dali::Radian *arg2 = 0 ;
35102   Dali::Vector3 *arg3 = 0 ;
35103
35104   arg1 = (Dali::Actor *)jarg1;
35105   arg2 = (Dali::Radian *)jarg2;
35106   if (!arg2) {
35107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35108     return ;
35109   }
35110   arg3 = (Dali::Vector3 *)jarg3;
35111   if (!arg3) {
35112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35113     return ;
35114   }
35115   {
35116     try {
35117       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35118     } catch (std::out_of_range& e) {
35119       {
35120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35121       };
35122     } catch (std::exception& e) {
35123       {
35124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35125       };
35126     } catch (Dali::DaliException e) {
35127       {
35128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35129       };
35130     } catch (...) {
35131       {
35132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35133       };
35134     }
35135   }
35136
35137 }
35138
35139
35140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35142   Dali::Quaternion *arg2 = 0 ;
35143
35144   arg1 = (Dali::Actor *)jarg1;
35145   arg2 = (Dali::Quaternion *)jarg2;
35146   if (!arg2) {
35147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35148     return ;
35149   }
35150   {
35151     try {
35152       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35153     } catch (std::out_of_range& e) {
35154       {
35155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35156       };
35157     } catch (std::exception& e) {
35158       {
35159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35160       };
35161     } catch (Dali::DaliException e) {
35162       {
35163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35164       };
35165     } catch (...) {
35166       {
35167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35168       };
35169     }
35170   }
35171
35172 }
35173
35174
35175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35176   void * jresult ;
35177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35178   Dali::Quaternion result;
35179
35180   arg1 = (Dali::Actor *)jarg1;
35181   {
35182     try {
35183       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35184     } catch (std::out_of_range& e) {
35185       {
35186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35187       };
35188     } catch (std::exception& e) {
35189       {
35190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35191       };
35192     } catch (Dali::DaliException e) {
35193       {
35194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35195       };
35196     } catch (...) {
35197       {
35198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35199       };
35200     }
35201   }
35202
35203   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35204   return jresult;
35205 }
35206
35207
35208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35209   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35210   bool arg2 ;
35211
35212   arg1 = (Dali::Actor *)jarg1;
35213   arg2 = jarg2 ? true : false;
35214   {
35215     try {
35216       (arg1)->SetInheritOrientation(arg2);
35217     } catch (std::out_of_range& e) {
35218       {
35219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35220       };
35221     } catch (std::exception& e) {
35222       {
35223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35224       };
35225     } catch (Dali::DaliException e) {
35226       {
35227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35228       };
35229     } catch (...) {
35230       {
35231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35232       };
35233     }
35234   }
35235
35236 }
35237
35238
35239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35240   unsigned int jresult ;
35241   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35242   bool result;
35243
35244   arg1 = (Dali::Actor *)jarg1;
35245   {
35246     try {
35247       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35248     } catch (std::out_of_range& e) {
35249       {
35250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35251       };
35252     } catch (std::exception& e) {
35253       {
35254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35255       };
35256     } catch (Dali::DaliException e) {
35257       {
35258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35259       };
35260     } catch (...) {
35261       {
35262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35263       };
35264     }
35265   }
35266
35267   jresult = result;
35268   return jresult;
35269 }
35270
35271
35272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35273   void * jresult ;
35274   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35275   Dali::Quaternion result;
35276
35277   arg1 = (Dali::Actor *)jarg1;
35278   {
35279     try {
35280       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35281     } catch (std::out_of_range& e) {
35282       {
35283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35284       };
35285     } catch (std::exception& e) {
35286       {
35287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35288       };
35289     } catch (Dali::DaliException e) {
35290       {
35291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35292       };
35293     } catch (...) {
35294       {
35295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35296       };
35297     }
35298   }
35299
35300   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35301   return jresult;
35302 }
35303
35304
35305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35306   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35307   float arg2 ;
35308
35309   arg1 = (Dali::Actor *)jarg1;
35310   arg2 = (float)jarg2;
35311   {
35312     try {
35313       (arg1)->SetScale(arg2);
35314     } catch (std::out_of_range& e) {
35315       {
35316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35317       };
35318     } catch (std::exception& e) {
35319       {
35320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35321       };
35322     } catch (Dali::DaliException e) {
35323       {
35324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35325       };
35326     } catch (...) {
35327       {
35328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35329       };
35330     }
35331   }
35332
35333 }
35334
35335
35336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35337   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35338   float arg2 ;
35339   float arg3 ;
35340   float arg4 ;
35341
35342   arg1 = (Dali::Actor *)jarg1;
35343   arg2 = (float)jarg2;
35344   arg3 = (float)jarg3;
35345   arg4 = (float)jarg4;
35346   {
35347     try {
35348       (arg1)->SetScale(arg2,arg3,arg4);
35349     } catch (std::out_of_range& e) {
35350       {
35351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35352       };
35353     } catch (std::exception& e) {
35354       {
35355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35356       };
35357     } catch (Dali::DaliException e) {
35358       {
35359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35360       };
35361     } catch (...) {
35362       {
35363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35364       };
35365     }
35366   }
35367
35368 }
35369
35370
35371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35372   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35373   Dali::Vector3 *arg2 = 0 ;
35374
35375   arg1 = (Dali::Actor *)jarg1;
35376   arg2 = (Dali::Vector3 *)jarg2;
35377   if (!arg2) {
35378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35379     return ;
35380   }
35381   {
35382     try {
35383       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35384     } catch (std::out_of_range& e) {
35385       {
35386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35387       };
35388     } catch (std::exception& e) {
35389       {
35390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35391       };
35392     } catch (Dali::DaliException e) {
35393       {
35394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35395       };
35396     } catch (...) {
35397       {
35398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35399       };
35400     }
35401   }
35402
35403 }
35404
35405
35406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35408   Dali::Vector3 *arg2 = 0 ;
35409
35410   arg1 = (Dali::Actor *)jarg1;
35411   arg2 = (Dali::Vector3 *)jarg2;
35412   if (!arg2) {
35413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35414     return ;
35415   }
35416   {
35417     try {
35418       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35419     } catch (std::out_of_range& e) {
35420       {
35421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35422       };
35423     } catch (std::exception& e) {
35424       {
35425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35426       };
35427     } catch (Dali::DaliException e) {
35428       {
35429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35430       };
35431     } catch (...) {
35432       {
35433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35434       };
35435     }
35436   }
35437
35438 }
35439
35440
35441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35442   void * jresult ;
35443   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35444   Dali::Vector3 result;
35445
35446   arg1 = (Dali::Actor *)jarg1;
35447   {
35448     try {
35449       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35450     } catch (std::out_of_range& e) {
35451       {
35452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35453       };
35454     } catch (std::exception& e) {
35455       {
35456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35457       };
35458     } catch (Dali::DaliException e) {
35459       {
35460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35461       };
35462     } catch (...) {
35463       {
35464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35465       };
35466     }
35467   }
35468
35469   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35470   return jresult;
35471 }
35472
35473
35474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35475   void * jresult ;
35476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35477   Dali::Vector3 result;
35478
35479   arg1 = (Dali::Actor *)jarg1;
35480   {
35481     try {
35482       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35483     } catch (std::out_of_range& e) {
35484       {
35485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35486       };
35487     } catch (std::exception& e) {
35488       {
35489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35490       };
35491     } catch (Dali::DaliException e) {
35492       {
35493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35494       };
35495     } catch (...) {
35496       {
35497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35498       };
35499     }
35500   }
35501
35502   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35503   return jresult;
35504 }
35505
35506
35507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35508   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35509   bool arg2 ;
35510
35511   arg1 = (Dali::Actor *)jarg1;
35512   arg2 = jarg2 ? true : false;
35513   {
35514     try {
35515       (arg1)->SetInheritScale(arg2);
35516     } catch (std::out_of_range& e) {
35517       {
35518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35519       };
35520     } catch (std::exception& e) {
35521       {
35522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35523       };
35524     } catch (Dali::DaliException e) {
35525       {
35526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35527       };
35528     } catch (...) {
35529       {
35530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35531       };
35532     }
35533   }
35534
35535 }
35536
35537
35538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35539   unsigned int jresult ;
35540   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35541   bool result;
35542
35543   arg1 = (Dali::Actor *)jarg1;
35544   {
35545     try {
35546       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35547     } catch (std::out_of_range& e) {
35548       {
35549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35550       };
35551     } catch (std::exception& e) {
35552       {
35553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35554       };
35555     } catch (Dali::DaliException e) {
35556       {
35557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35558       };
35559     } catch (...) {
35560       {
35561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35562       };
35563     }
35564   }
35565
35566   jresult = result;
35567   return jresult;
35568 }
35569
35570
35571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35572   void * jresult ;
35573   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35574   Dali::Matrix result;
35575
35576   arg1 = (Dali::Actor *)jarg1;
35577   {
35578     try {
35579       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35580     } catch (std::out_of_range& e) {
35581       {
35582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35583       };
35584     } catch (std::exception& e) {
35585       {
35586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35587       };
35588     } catch (Dali::DaliException e) {
35589       {
35590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35591       };
35592     } catch (...) {
35593       {
35594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35595       };
35596     }
35597   }
35598
35599   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35600   return jresult;
35601 }
35602
35603
35604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35605   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35606   bool arg2 ;
35607
35608   arg1 = (Dali::Actor *)jarg1;
35609   arg2 = jarg2 ? true : false;
35610   {
35611     try {
35612       (arg1)->SetVisible(arg2);
35613     } catch (std::out_of_range& e) {
35614       {
35615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35616       };
35617     } catch (std::exception& e) {
35618       {
35619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35620       };
35621     } catch (Dali::DaliException e) {
35622       {
35623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35624       };
35625     } catch (...) {
35626       {
35627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35628       };
35629     }
35630   }
35631
35632 }
35633
35634
35635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35636   unsigned int jresult ;
35637   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35638   bool result;
35639
35640   arg1 = (Dali::Actor *)jarg1;
35641   {
35642     try {
35643       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35644     } catch (std::out_of_range& e) {
35645       {
35646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35647       };
35648     } catch (std::exception& e) {
35649       {
35650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35651       };
35652     } catch (Dali::DaliException e) {
35653       {
35654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35655       };
35656     } catch (...) {
35657       {
35658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35659       };
35660     }
35661   }
35662
35663   jresult = result;
35664   return jresult;
35665 }
35666
35667
35668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35669   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35670   float arg2 ;
35671
35672   arg1 = (Dali::Actor *)jarg1;
35673   arg2 = (float)jarg2;
35674   {
35675     try {
35676       (arg1)->SetOpacity(arg2);
35677     } catch (std::out_of_range& e) {
35678       {
35679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35680       };
35681     } catch (std::exception& e) {
35682       {
35683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35684       };
35685     } catch (Dali::DaliException e) {
35686       {
35687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35688       };
35689     } catch (...) {
35690       {
35691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35692       };
35693     }
35694   }
35695
35696 }
35697
35698
35699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35700   float jresult ;
35701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35702   float result;
35703
35704   arg1 = (Dali::Actor *)jarg1;
35705   {
35706     try {
35707       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35708     } catch (std::out_of_range& e) {
35709       {
35710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35711       };
35712     } catch (std::exception& e) {
35713       {
35714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35715       };
35716     } catch (Dali::DaliException e) {
35717       {
35718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35719       };
35720     } catch (...) {
35721       {
35722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35723       };
35724     }
35725   }
35726
35727   jresult = result;
35728   return jresult;
35729 }
35730
35731
35732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35733   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35734   Dali::Vector4 *arg2 = 0 ;
35735
35736   arg1 = (Dali::Actor *)jarg1;
35737   arg2 = (Dali::Vector4 *)jarg2;
35738   if (!arg2) {
35739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35740     return ;
35741   }
35742   {
35743     try {
35744       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35745     } catch (std::out_of_range& e) {
35746       {
35747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35748       };
35749     } catch (std::exception& e) {
35750       {
35751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35752       };
35753     } catch (Dali::DaliException e) {
35754       {
35755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35756       };
35757     } catch (...) {
35758       {
35759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35760       };
35761     }
35762   }
35763
35764 }
35765
35766
35767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35768   void * jresult ;
35769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35770   Dali::Vector4 result;
35771
35772   arg1 = (Dali::Actor *)jarg1;
35773   {
35774     try {
35775       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35776     } catch (std::out_of_range& e) {
35777       {
35778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35779       };
35780     } catch (std::exception& e) {
35781       {
35782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35783       };
35784     } catch (Dali::DaliException e) {
35785       {
35786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35787       };
35788     } catch (...) {
35789       {
35790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35791       };
35792     }
35793   }
35794
35795   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35796   return jresult;
35797 }
35798
35799
35800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35802   Dali::ColorMode arg2 ;
35803
35804   arg1 = (Dali::Actor *)jarg1;
35805   arg2 = (Dali::ColorMode)jarg2;
35806   {
35807     try {
35808       (arg1)->SetColorMode(arg2);
35809     } catch (std::out_of_range& e) {
35810       {
35811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35812       };
35813     } catch (std::exception& e) {
35814       {
35815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35816       };
35817     } catch (Dali::DaliException e) {
35818       {
35819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35820       };
35821     } catch (...) {
35822       {
35823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35824       };
35825     }
35826   }
35827
35828 }
35829
35830
35831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35832   int jresult ;
35833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35834   Dali::ColorMode result;
35835
35836   arg1 = (Dali::Actor *)jarg1;
35837   {
35838     try {
35839       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35840     } catch (std::out_of_range& e) {
35841       {
35842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35843       };
35844     } catch (std::exception& e) {
35845       {
35846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35847       };
35848     } catch (Dali::DaliException e) {
35849       {
35850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35851       };
35852     } catch (...) {
35853       {
35854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35855       };
35856     }
35857   }
35858
35859   jresult = (int)result;
35860   return jresult;
35861 }
35862
35863
35864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35865   void * jresult ;
35866   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35867   Dali::Vector4 result;
35868
35869   arg1 = (Dali::Actor *)jarg1;
35870   {
35871     try {
35872       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35873     } catch (std::out_of_range& e) {
35874       {
35875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35876       };
35877     } catch (std::exception& e) {
35878       {
35879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35880       };
35881     } catch (Dali::DaliException e) {
35882       {
35883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35884       };
35885     } catch (...) {
35886       {
35887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35888       };
35889     }
35890   }
35891
35892   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35893   return jresult;
35894 }
35895
35896
35897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35898   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35899   Dali::DrawMode::Type arg2 ;
35900
35901   arg1 = (Dali::Actor *)jarg1;
35902   arg2 = (Dali::DrawMode::Type)jarg2;
35903   {
35904     try {
35905       (arg1)->SetDrawMode(arg2);
35906     } catch (std::out_of_range& e) {
35907       {
35908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35909       };
35910     } catch (std::exception& e) {
35911       {
35912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35913       };
35914     } catch (Dali::DaliException e) {
35915       {
35916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35917       };
35918     } catch (...) {
35919       {
35920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35921       };
35922     }
35923   }
35924
35925 }
35926
35927
35928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35929   int jresult ;
35930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35931   Dali::DrawMode::Type result;
35932
35933   arg1 = (Dali::Actor *)jarg1;
35934   {
35935     try {
35936       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35937     } catch (std::out_of_range& e) {
35938       {
35939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35940       };
35941     } catch (std::exception& e) {
35942       {
35943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35944       };
35945     } catch (Dali::DaliException e) {
35946       {
35947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35948       };
35949     } catch (...) {
35950       {
35951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35952       };
35953     }
35954   }
35955
35956   jresult = (int)result;
35957   return jresult;
35958 }
35959
35960
35961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35962   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35963   bool arg2 ;
35964
35965   arg1 = (Dali::Actor *)jarg1;
35966   arg2 = jarg2 ? true : false;
35967   {
35968     try {
35969       (arg1)->SetSensitive(arg2);
35970     } catch (std::out_of_range& e) {
35971       {
35972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35973       };
35974     } catch (std::exception& e) {
35975       {
35976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35977       };
35978     } catch (Dali::DaliException e) {
35979       {
35980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35981       };
35982     } catch (...) {
35983       {
35984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35985       };
35986     }
35987   }
35988
35989 }
35990
35991
35992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35993   unsigned int jresult ;
35994   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35995   bool result;
35996
35997   arg1 = (Dali::Actor *)jarg1;
35998   {
35999     try {
36000       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36001     } catch (std::out_of_range& e) {
36002       {
36003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36004       };
36005     } catch (std::exception& e) {
36006       {
36007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36008       };
36009     } catch (Dali::DaliException e) {
36010       {
36011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36012       };
36013     } catch (...) {
36014       {
36015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36016       };
36017     }
36018   }
36019
36020   jresult = result;
36021   return jresult;
36022 }
36023
36024
36025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36026   unsigned int jresult ;
36027   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36028   float *arg2 = 0 ;
36029   float *arg3 = 0 ;
36030   float arg4 ;
36031   float arg5 ;
36032   bool result;
36033
36034   arg1 = (Dali::Actor *)jarg1;
36035   arg2 = (float *)jarg2;
36036   arg3 = (float *)jarg3;
36037   arg4 = (float)jarg4;
36038   arg5 = (float)jarg5;
36039   {
36040     try {
36041       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36042     } catch (std::out_of_range& e) {
36043       {
36044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36045       };
36046     } catch (std::exception& e) {
36047       {
36048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36049       };
36050     } catch (Dali::DaliException e) {
36051       {
36052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36053       };
36054     } catch (...) {
36055       {
36056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36057       };
36058     }
36059   }
36060
36061   jresult = result;
36062   return jresult;
36063 }
36064
36065
36066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36067   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36068   bool arg2 ;
36069
36070   arg1 = (Dali::Actor *)jarg1;
36071   arg2 = jarg2 ? true : false;
36072   {
36073     try {
36074       (arg1)->SetLeaveRequired(arg2);
36075     } catch (std::out_of_range& e) {
36076       {
36077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36078       };
36079     } catch (std::exception& e) {
36080       {
36081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36082       };
36083     } catch (Dali::DaliException e) {
36084       {
36085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36086       };
36087     } catch (...) {
36088       {
36089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36090       };
36091     }
36092   }
36093
36094 }
36095
36096
36097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36098   unsigned int jresult ;
36099   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36100   bool result;
36101
36102   arg1 = (Dali::Actor *)jarg1;
36103   {
36104     try {
36105       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36106     } catch (std::out_of_range& e) {
36107       {
36108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36109       };
36110     } catch (std::exception& e) {
36111       {
36112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36113       };
36114     } catch (Dali::DaliException e) {
36115       {
36116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36117       };
36118     } catch (...) {
36119       {
36120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36121       };
36122     }
36123   }
36124
36125   jresult = result;
36126   return jresult;
36127 }
36128
36129
36130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36132   bool arg2 ;
36133
36134   arg1 = (Dali::Actor *)jarg1;
36135   arg2 = jarg2 ? true : false;
36136   {
36137     try {
36138       (arg1)->SetKeyboardFocusable(arg2);
36139     } catch (std::out_of_range& e) {
36140       {
36141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36142       };
36143     } catch (std::exception& e) {
36144       {
36145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36146       };
36147     } catch (Dali::DaliException e) {
36148       {
36149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36150       };
36151     } catch (...) {
36152       {
36153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36154       };
36155     }
36156   }
36157
36158 }
36159
36160
36161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36162   unsigned int jresult ;
36163   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36164   bool result;
36165
36166   arg1 = (Dali::Actor *)jarg1;
36167   {
36168     try {
36169       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36170     } catch (std::out_of_range& e) {
36171       {
36172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36173       };
36174     } catch (std::exception& e) {
36175       {
36176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36177       };
36178     } catch (Dali::DaliException e) {
36179       {
36180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36181       };
36182     } catch (...) {
36183       {
36184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36185       };
36186     }
36187   }
36188
36189   jresult = result;
36190   return jresult;
36191 }
36192
36193
36194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36195   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36196   Dali::ResizePolicy::Type arg2 ;
36197   Dali::Dimension::Type arg3 ;
36198
36199   arg1 = (Dali::Actor *)jarg1;
36200   arg2 = (Dali::ResizePolicy::Type)jarg2;
36201   arg3 = (Dali::Dimension::Type)jarg3;
36202   {
36203     try {
36204       (arg1)->SetResizePolicy(arg2,arg3);
36205     } catch (std::out_of_range& e) {
36206       {
36207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36208       };
36209     } catch (std::exception& e) {
36210       {
36211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36212       };
36213     } catch (Dali::DaliException e) {
36214       {
36215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36216       };
36217     } catch (...) {
36218       {
36219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36220       };
36221     }
36222   }
36223
36224 }
36225
36226
36227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36228   int jresult ;
36229   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36230   Dali::Dimension::Type arg2 ;
36231   Dali::ResizePolicy::Type result;
36232
36233   arg1 = (Dali::Actor *)jarg1;
36234   arg2 = (Dali::Dimension::Type)jarg2;
36235   {
36236     try {
36237       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36238     } catch (std::out_of_range& e) {
36239       {
36240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36241       };
36242     } catch (std::exception& e) {
36243       {
36244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36245       };
36246     } catch (Dali::DaliException e) {
36247       {
36248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36249       };
36250     } catch (...) {
36251       {
36252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36253       };
36254     }
36255   }
36256
36257   jresult = (int)result;
36258   return jresult;
36259 }
36260
36261
36262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36263   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36264   Dali::SizeScalePolicy::Type arg2 ;
36265
36266   arg1 = (Dali::Actor *)jarg1;
36267   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36268   {
36269     try {
36270       (arg1)->SetSizeScalePolicy(arg2);
36271     } catch (std::out_of_range& e) {
36272       {
36273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36274       };
36275     } catch (std::exception& e) {
36276       {
36277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36278       };
36279     } catch (Dali::DaliException e) {
36280       {
36281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36282       };
36283     } catch (...) {
36284       {
36285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36286       };
36287     }
36288   }
36289
36290 }
36291
36292
36293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36294   int jresult ;
36295   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36296   Dali::SizeScalePolicy::Type result;
36297
36298   arg1 = (Dali::Actor *)jarg1;
36299   {
36300     try {
36301       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36302     } catch (std::out_of_range& e) {
36303       {
36304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36305       };
36306     } catch (std::exception& e) {
36307       {
36308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36309       };
36310     } catch (Dali::DaliException e) {
36311       {
36312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36313       };
36314     } catch (...) {
36315       {
36316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36317       };
36318     }
36319   }
36320
36321   jresult = (int)result;
36322   return jresult;
36323 }
36324
36325
36326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36328   Dali::Vector3 *arg2 = 0 ;
36329
36330   arg1 = (Dali::Actor *)jarg1;
36331   arg2 = (Dali::Vector3 *)jarg2;
36332   if (!arg2) {
36333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36334     return ;
36335   }
36336   {
36337     try {
36338       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36339     } catch (std::out_of_range& e) {
36340       {
36341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36342       };
36343     } catch (std::exception& e) {
36344       {
36345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36346       };
36347     } catch (Dali::DaliException e) {
36348       {
36349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36350       };
36351     } catch (...) {
36352       {
36353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36354       };
36355     }
36356   }
36357
36358 }
36359
36360
36361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36362   void * jresult ;
36363   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36364   Dali::Vector3 result;
36365
36366   arg1 = (Dali::Actor *)jarg1;
36367   {
36368     try {
36369       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36370     } catch (std::out_of_range& e) {
36371       {
36372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36373       };
36374     } catch (std::exception& e) {
36375       {
36376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36377       };
36378     } catch (Dali::DaliException e) {
36379       {
36380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36381       };
36382     } catch (...) {
36383       {
36384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36385       };
36386     }
36387   }
36388
36389   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36390   return jresult;
36391 }
36392
36393
36394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36395   float jresult ;
36396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36397   float arg2 ;
36398   float result;
36399
36400   arg1 = (Dali::Actor *)jarg1;
36401   arg2 = (float)jarg2;
36402   {
36403     try {
36404       result = (float)(arg1)->GetHeightForWidth(arg2);
36405     } catch (std::out_of_range& e) {
36406       {
36407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36408       };
36409     } catch (std::exception& e) {
36410       {
36411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36412       };
36413     } catch (Dali::DaliException e) {
36414       {
36415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36416       };
36417     } catch (...) {
36418       {
36419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36420       };
36421     }
36422   }
36423
36424   jresult = result;
36425   return jresult;
36426 }
36427
36428
36429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36430   float jresult ;
36431   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36432   float arg2 ;
36433   float result;
36434
36435   arg1 = (Dali::Actor *)jarg1;
36436   arg2 = (float)jarg2;
36437   {
36438     try {
36439       result = (float)(arg1)->GetWidthForHeight(arg2);
36440     } catch (std::out_of_range& e) {
36441       {
36442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36443       };
36444     } catch (std::exception& e) {
36445       {
36446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36447       };
36448     } catch (Dali::DaliException e) {
36449       {
36450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36451       };
36452     } catch (...) {
36453       {
36454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36455       };
36456     }
36457   }
36458
36459   jresult = result;
36460   return jresult;
36461 }
36462
36463
36464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36465   float jresult ;
36466   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36467   Dali::Dimension::Type arg2 ;
36468   float result;
36469
36470   arg1 = (Dali::Actor *)jarg1;
36471   arg2 = (Dali::Dimension::Type)jarg2;
36472   {
36473     try {
36474       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36475     } catch (std::out_of_range& e) {
36476       {
36477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36478       };
36479     } catch (std::exception& e) {
36480       {
36481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36482       };
36483     } catch (Dali::DaliException e) {
36484       {
36485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36486       };
36487     } catch (...) {
36488       {
36489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36490       };
36491     }
36492   }
36493
36494   jresult = result;
36495   return jresult;
36496 }
36497
36498
36499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36500   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36501   Dali::Padding *arg2 = 0 ;
36502
36503   arg1 = (Dali::Actor *)jarg1;
36504   arg2 = (Dali::Padding *)jarg2;
36505   if (!arg2) {
36506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36507     return ;
36508   }
36509   {
36510     try {
36511       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36512     } catch (std::out_of_range& e) {
36513       {
36514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36515       };
36516     } catch (std::exception& e) {
36517       {
36518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36519       };
36520     } catch (Dali::DaliException e) {
36521       {
36522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36523       };
36524     } catch (...) {
36525       {
36526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36527       };
36528     }
36529   }
36530
36531 }
36532
36533
36534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36535   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36536   Dali::Padding *arg2 = 0 ;
36537
36538   arg1 = (Dali::Actor *)jarg1;
36539   arg2 = (Dali::Padding *)jarg2;
36540   if (!arg2) {
36541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36542     return ;
36543   }
36544   {
36545     try {
36546       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36547     } catch (std::out_of_range& e) {
36548       {
36549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36550       };
36551     } catch (std::exception& e) {
36552       {
36553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36554       };
36555     } catch (Dali::DaliException e) {
36556       {
36557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36558       };
36559     } catch (...) {
36560       {
36561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36562       };
36563     }
36564   }
36565
36566 }
36567
36568
36569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36570   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36571   Dali::Vector2 *arg2 = 0 ;
36572
36573   arg1 = (Dali::Actor *)jarg1;
36574   arg2 = (Dali::Vector2 *)jarg2;
36575   if (!arg2) {
36576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36577     return ;
36578   }
36579   {
36580     try {
36581       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36582     } catch (std::out_of_range& e) {
36583       {
36584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36585       };
36586     } catch (std::exception& e) {
36587       {
36588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36589       };
36590     } catch (Dali::DaliException e) {
36591       {
36592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36593       };
36594     } catch (...) {
36595       {
36596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36597       };
36598     }
36599   }
36600
36601 }
36602
36603
36604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36605   void * jresult ;
36606   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36607   Dali::Vector2 result;
36608
36609   arg1 = (Dali::Actor *)jarg1;
36610   {
36611     try {
36612       result = (arg1)->GetMinimumSize();
36613     } catch (std::out_of_range& e) {
36614       {
36615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36616       };
36617     } catch (std::exception& e) {
36618       {
36619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36620       };
36621     } catch (Dali::DaliException e) {
36622       {
36623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36624       };
36625     } catch (...) {
36626       {
36627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36628       };
36629     }
36630   }
36631
36632   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36633   return jresult;
36634 }
36635
36636
36637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36639   Dali::Vector2 *arg2 = 0 ;
36640
36641   arg1 = (Dali::Actor *)jarg1;
36642   arg2 = (Dali::Vector2 *)jarg2;
36643   if (!arg2) {
36644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36645     return ;
36646   }
36647   {
36648     try {
36649       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36650     } catch (std::out_of_range& e) {
36651       {
36652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36653       };
36654     } catch (std::exception& e) {
36655       {
36656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36657       };
36658     } catch (Dali::DaliException e) {
36659       {
36660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36661       };
36662     } catch (...) {
36663       {
36664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36665       };
36666     }
36667   }
36668
36669 }
36670
36671
36672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36673   void * jresult ;
36674   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36675   Dali::Vector2 result;
36676
36677   arg1 = (Dali::Actor *)jarg1;
36678   {
36679     try {
36680       result = (arg1)->GetMaximumSize();
36681     } catch (std::out_of_range& e) {
36682       {
36683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36684       };
36685     } catch (std::exception& e) {
36686       {
36687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36688       };
36689     } catch (Dali::DaliException e) {
36690       {
36691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36692       };
36693     } catch (...) {
36694       {
36695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36696       };
36697     }
36698   }
36699
36700   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36701   return jresult;
36702 }
36703
36704
36705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36706   int jresult ;
36707   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36708   int result;
36709
36710   arg1 = (Dali::Actor *)jarg1;
36711   {
36712     try {
36713       result = (int)(arg1)->GetHierarchyDepth();
36714       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36715     } catch (std::out_of_range& e) {
36716       {
36717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36718       };
36719     } catch (std::exception& e) {
36720       {
36721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36722       };
36723     } catch (Dali::DaliException e) {
36724       {
36725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36726       };
36727     } catch (...) {
36728       {
36729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36730       };
36731     }
36732   }
36733
36734   jresult = result;
36735   return jresult;
36736 }
36737
36738
36739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36740   unsigned int jresult ;
36741   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36742   Dali::Renderer *arg2 = 0 ;
36743   unsigned int result;
36744
36745   arg1 = (Dali::Actor *)jarg1;
36746   arg2 = (Dali::Renderer *)jarg2;
36747   if (!arg2) {
36748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36749     return 0;
36750   }
36751   {
36752     try {
36753       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36754     } catch (std::out_of_range& e) {
36755       {
36756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36757       };
36758     } catch (std::exception& e) {
36759       {
36760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36761       };
36762     } catch (Dali::DaliException e) {
36763       {
36764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36765       };
36766     } catch (...) {
36767       {
36768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36769       };
36770     }
36771   }
36772
36773   jresult = result;
36774   return jresult;
36775 }
36776
36777
36778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36779   unsigned int jresult ;
36780   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36781   unsigned int result;
36782
36783   arg1 = (Dali::Actor *)jarg1;
36784   {
36785     try {
36786       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36787     } catch (std::out_of_range& e) {
36788       {
36789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36790       };
36791     } catch (std::exception& e) {
36792       {
36793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36794       };
36795     } catch (Dali::DaliException e) {
36796       {
36797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36798       };
36799     } catch (...) {
36800       {
36801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36802       };
36803     }
36804   }
36805
36806   jresult = result;
36807   return jresult;
36808 }
36809
36810
36811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36812   void * jresult ;
36813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36814   unsigned int arg2 ;
36815   Dali::Renderer result;
36816
36817   arg1 = (Dali::Actor *)jarg1;
36818   arg2 = (unsigned int)jarg2;
36819   {
36820     try {
36821       result = (arg1)->GetRendererAt(arg2);
36822     } catch (std::out_of_range& e) {
36823       {
36824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36825       };
36826     } catch (std::exception& e) {
36827       {
36828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36829       };
36830     } catch (Dali::DaliException e) {
36831       {
36832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36833       };
36834     } catch (...) {
36835       {
36836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36837       };
36838     }
36839   }
36840
36841   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36842   return jresult;
36843 }
36844
36845
36846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36847   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36848   Dali::Renderer *arg2 = 0 ;
36849
36850   arg1 = (Dali::Actor *)jarg1;
36851   arg2 = (Dali::Renderer *)jarg2;
36852   if (!arg2) {
36853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36854     return ;
36855   }
36856   {
36857     try {
36858       (arg1)->RemoveRenderer(*arg2);
36859     } catch (std::out_of_range& e) {
36860       {
36861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36862       };
36863     } catch (std::exception& e) {
36864       {
36865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36866       };
36867     } catch (Dali::DaliException e) {
36868       {
36869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36870       };
36871     } catch (...) {
36872       {
36873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36874       };
36875     }
36876   }
36877
36878 }
36879
36880
36881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36882   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36883   unsigned int arg2 ;
36884
36885   arg1 = (Dali::Actor *)jarg1;
36886   arg2 = (unsigned int)jarg2;
36887   {
36888     try {
36889       (arg1)->RemoveRenderer(arg2);
36890     } catch (std::out_of_range& e) {
36891       {
36892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36893       };
36894     } catch (std::exception& e) {
36895       {
36896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36897       };
36898     } catch (Dali::DaliException e) {
36899       {
36900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36901       };
36902     } catch (...) {
36903       {
36904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36905       };
36906     }
36907   }
36908
36909 }
36910
36911
36912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36913   void * jresult ;
36914   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36915   Dali::Actor::TouchSignalType *result = 0 ;
36916
36917   arg1 = (Dali::Actor *)jarg1;
36918   {
36919     try {
36920       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36921     } catch (std::out_of_range& e) {
36922       {
36923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36924       };
36925     } catch (std::exception& e) {
36926       {
36927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36928       };
36929     } catch (Dali::DaliException e) {
36930       {
36931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36932       };
36933     } catch (...) {
36934       {
36935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36936       };
36937     }
36938   }
36939
36940   jresult = (void *)result;
36941   return jresult;
36942 }
36943
36944
36945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36946   void * jresult ;
36947   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36948   Dali::Actor::TouchDataSignalType *result = 0 ;
36949
36950   arg1 = (Dali::Actor *)jarg1;
36951   {
36952     try {
36953       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36954     } catch (std::out_of_range& e) {
36955       {
36956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36957       };
36958     } catch (std::exception& e) {
36959       {
36960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36961       };
36962     } catch (Dali::DaliException e) {
36963       {
36964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36965       };
36966     } catch (...) {
36967       {
36968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36969       };
36970     }
36971   }
36972
36973   jresult = (void *)result;
36974   return jresult;
36975 }
36976
36977
36978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36979   void * jresult ;
36980   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36981   Dali::Actor::HoverSignalType *result = 0 ;
36982
36983   arg1 = (Dali::Actor *)jarg1;
36984   {
36985     try {
36986       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36987     } catch (std::out_of_range& e) {
36988       {
36989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36990       };
36991     } catch (std::exception& e) {
36992       {
36993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36994       };
36995     } catch (Dali::DaliException e) {
36996       {
36997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36998       };
36999     } catch (...) {
37000       {
37001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37002       };
37003     }
37004   }
37005
37006   jresult = (void *)result;
37007   return jresult;
37008 }
37009
37010
37011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37012   void * jresult ;
37013   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37014   Dali::Actor::WheelEventSignalType *result = 0 ;
37015
37016   arg1 = (Dali::Actor *)jarg1;
37017   {
37018     try {
37019       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37020     } catch (std::out_of_range& e) {
37021       {
37022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37023       };
37024     } catch (std::exception& e) {
37025       {
37026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37027       };
37028     } catch (Dali::DaliException e) {
37029       {
37030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37031       };
37032     } catch (...) {
37033       {
37034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37035       };
37036     }
37037   }
37038
37039   jresult = (void *)result;
37040   return jresult;
37041 }
37042
37043
37044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37045   void * jresult ;
37046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37047   Dali::Actor::OnStageSignalType *result = 0 ;
37048
37049   arg1 = (Dali::Actor *)jarg1;
37050   {
37051     try {
37052       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37053     } catch (std::out_of_range& e) {
37054       {
37055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37056       };
37057     } catch (std::exception& e) {
37058       {
37059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37060       };
37061     } catch (Dali::DaliException e) {
37062       {
37063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37064       };
37065     } catch (...) {
37066       {
37067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37068       };
37069     }
37070   }
37071
37072   jresult = (void *)result;
37073   return jresult;
37074 }
37075
37076
37077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37078   void * jresult ;
37079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37080   Dali::Actor::OffStageSignalType *result = 0 ;
37081
37082   arg1 = (Dali::Actor *)jarg1;
37083   {
37084     try {
37085       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37086     } catch (std::out_of_range& e) {
37087       {
37088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37089       };
37090     } catch (std::exception& e) {
37091       {
37092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37093       };
37094     } catch (Dali::DaliException e) {
37095       {
37096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37097       };
37098     } catch (...) {
37099       {
37100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37101       };
37102     }
37103   }
37104
37105   jresult = (void *)result;
37106   return jresult;
37107 }
37108
37109
37110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37111   void * jresult ;
37112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37113   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37114
37115   arg1 = (Dali::Actor *)jarg1;
37116   {
37117     try {
37118       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37119     } catch (std::out_of_range& e) {
37120       {
37121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37122       };
37123     } catch (std::exception& e) {
37124       {
37125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37126       };
37127     } catch (Dali::DaliException e) {
37128       {
37129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37130       };
37131     } catch (...) {
37132       {
37133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37134       };
37135     }
37136   }
37137
37138   jresult = (void *)result;
37139   return jresult;
37140 }
37141
37142
37143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37144   Dali::Actor *arg1 = 0 ;
37145
37146   arg1 = (Dali::Actor *)jarg1;
37147   if (!arg1) {
37148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37149     return ;
37150   }
37151   {
37152     try {
37153       Dali::UnparentAndReset(*arg1);
37154     } catch (std::out_of_range& e) {
37155       {
37156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37157       };
37158     } catch (std::exception& e) {
37159       {
37160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37161       };
37162     } catch (Dali::DaliException e) {
37163       {
37164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37165       };
37166     } catch (...) {
37167       {
37168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37169       };
37170     }
37171   }
37172
37173 }
37174
37175
37176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37177   int jresult ;
37178   int result;
37179
37180   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37181   jresult = (int)result;
37182   return jresult;
37183 }
37184
37185
37186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37187   int jresult ;
37188   int result;
37189
37190   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37191   jresult = (int)result;
37192   return jresult;
37193 }
37194
37195
37196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37197   int jresult ;
37198   int result;
37199
37200   result = (int)Dali::Layer::Property::BEHAVIOR;
37201   jresult = (int)result;
37202   return jresult;
37203 }
37204
37205
37206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37207   void * jresult ;
37208   Dali::Layer::Property *result = 0 ;
37209
37210   {
37211     try {
37212       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37213     } catch (std::out_of_range& e) {
37214       {
37215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37216       };
37217     } catch (std::exception& e) {
37218       {
37219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37220       };
37221     } catch (Dali::DaliException e) {
37222       {
37223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37224       };
37225     } catch (...) {
37226       {
37227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37228       };
37229     }
37230   }
37231
37232   jresult = (void *)result;
37233   return jresult;
37234 }
37235
37236
37237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37238   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37239
37240   arg1 = (Dali::Layer::Property *)jarg1;
37241   {
37242     try {
37243       delete arg1;
37244     } catch (std::out_of_range& e) {
37245       {
37246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37247       };
37248     } catch (std::exception& e) {
37249       {
37250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37251       };
37252     } catch (Dali::DaliException e) {
37253       {
37254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37255       };
37256     } catch (...) {
37257       {
37258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37259       };
37260     }
37261   }
37262
37263 }
37264
37265
37266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37267   void * jresult ;
37268   Dali::Layer *result = 0 ;
37269
37270   {
37271     try {
37272       result = (Dali::Layer *)new Dali::Layer();
37273     } catch (std::out_of_range& e) {
37274       {
37275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37276       };
37277     } catch (std::exception& e) {
37278       {
37279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37280       };
37281     } catch (Dali::DaliException e) {
37282       {
37283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37284       };
37285     } catch (...) {
37286       {
37287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37288       };
37289     }
37290   }
37291
37292   jresult = (void *)result;
37293   return jresult;
37294 }
37295
37296
37297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37298   void * jresult ;
37299   Dali::Layer result;
37300
37301   {
37302     try {
37303       result = Dali::Layer::New();
37304     } catch (std::out_of_range& e) {
37305       {
37306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37307       };
37308     } catch (std::exception& e) {
37309       {
37310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37311       };
37312     } catch (Dali::DaliException e) {
37313       {
37314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37315       };
37316     } catch (...) {
37317       {
37318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37319       };
37320     }
37321   }
37322
37323   jresult = new Dali::Layer((const Dali::Layer &)result);
37324   return jresult;
37325 }
37326
37327
37328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37329   void * jresult ;
37330   Dali::BaseHandle arg1 ;
37331   Dali::BaseHandle *argp1 ;
37332   Dali::Layer result;
37333
37334   argp1 = (Dali::BaseHandle *)jarg1;
37335   if (!argp1) {
37336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37337     return 0;
37338   }
37339   arg1 = *argp1;
37340   {
37341     try {
37342       result = Dali::Layer::DownCast(arg1);
37343     } catch (std::out_of_range& e) {
37344       {
37345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37346       };
37347     } catch (std::exception& e) {
37348       {
37349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37350       };
37351     } catch (Dali::DaliException e) {
37352       {
37353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37354       };
37355     } catch (...) {
37356       {
37357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37358       };
37359     }
37360   }
37361
37362   jresult = new Dali::Layer((const Dali::Layer &)result);
37363   return jresult;
37364 }
37365
37366
37367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37368   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37369
37370   arg1 = (Dali::Layer *)jarg1;
37371   {
37372     try {
37373       delete arg1;
37374     } catch (std::out_of_range& e) {
37375       {
37376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37377       };
37378     } catch (std::exception& e) {
37379       {
37380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37381       };
37382     } catch (Dali::DaliException e) {
37383       {
37384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37385       };
37386     } catch (...) {
37387       {
37388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37389       };
37390     }
37391   }
37392
37393 }
37394
37395
37396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37397   void * jresult ;
37398   Dali::Layer *arg1 = 0 ;
37399   Dali::Layer *result = 0 ;
37400
37401   arg1 = (Dali::Layer *)jarg1;
37402   if (!arg1) {
37403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37404     return 0;
37405   }
37406   {
37407     try {
37408       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37409     } catch (std::out_of_range& e) {
37410       {
37411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37412       };
37413     } catch (std::exception& e) {
37414       {
37415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37416       };
37417     } catch (Dali::DaliException e) {
37418       {
37419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37420       };
37421     } catch (...) {
37422       {
37423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37424       };
37425     }
37426   }
37427
37428   jresult = (void *)result;
37429   return jresult;
37430 }
37431
37432
37433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37434   void * jresult ;
37435   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37436   Dali::Layer *arg2 = 0 ;
37437   Dali::Layer *result = 0 ;
37438
37439   arg1 = (Dali::Layer *)jarg1;
37440   arg2 = (Dali::Layer *)jarg2;
37441   if (!arg2) {
37442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37443     return 0;
37444   }
37445   {
37446     try {
37447       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37448     } catch (std::out_of_range& e) {
37449       {
37450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37451       };
37452     } catch (std::exception& e) {
37453       {
37454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37455       };
37456     } catch (Dali::DaliException e) {
37457       {
37458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37459       };
37460     } catch (...) {
37461       {
37462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37463       };
37464     }
37465   }
37466
37467   jresult = (void *)result;
37468   return jresult;
37469 }
37470
37471
37472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37473   unsigned int jresult ;
37474   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37475   unsigned int result;
37476
37477   arg1 = (Dali::Layer *)jarg1;
37478   {
37479     try {
37480       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37481     } catch (std::out_of_range& e) {
37482       {
37483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37484       };
37485     } catch (std::exception& e) {
37486       {
37487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37488       };
37489     } catch (Dali::DaliException e) {
37490       {
37491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37492       };
37493     } catch (...) {
37494       {
37495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37496       };
37497     }
37498   }
37499
37500   jresult = result;
37501   return jresult;
37502 }
37503
37504
37505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37506   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37507
37508   arg1 = (Dali::Layer *)jarg1;
37509   {
37510     try {
37511       (arg1)->Raise();
37512     } catch (std::out_of_range& e) {
37513       {
37514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37515       };
37516     } catch (std::exception& e) {
37517       {
37518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37519       };
37520     } catch (Dali::DaliException e) {
37521       {
37522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37523       };
37524     } catch (...) {
37525       {
37526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37527       };
37528     }
37529   }
37530
37531 }
37532
37533
37534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37535   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37536
37537   arg1 = (Dali::Layer *)jarg1;
37538   {
37539     try {
37540       (arg1)->Lower();
37541     } catch (std::out_of_range& e) {
37542       {
37543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37544       };
37545     } catch (std::exception& e) {
37546       {
37547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37548       };
37549     } catch (Dali::DaliException e) {
37550       {
37551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37552       };
37553     } catch (...) {
37554       {
37555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37556       };
37557     }
37558   }
37559
37560 }
37561
37562
37563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37564   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37565   Dali::Layer arg2 ;
37566   Dali::Layer *argp2 ;
37567
37568   arg1 = (Dali::Layer *)jarg1;
37569   argp2 = (Dali::Layer *)jarg2;
37570   if (!argp2) {
37571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37572     return ;
37573   }
37574   arg2 = *argp2;
37575   {
37576     try {
37577       (arg1)->RaiseAbove(arg2);
37578     } catch (std::out_of_range& e) {
37579       {
37580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37581       };
37582     } catch (std::exception& e) {
37583       {
37584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37585       };
37586     } catch (Dali::DaliException e) {
37587       {
37588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37589       };
37590     } catch (...) {
37591       {
37592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37593       };
37594     }
37595   }
37596
37597 }
37598
37599
37600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37601   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37602   Dali::Layer arg2 ;
37603   Dali::Layer *argp2 ;
37604
37605   arg1 = (Dali::Layer *)jarg1;
37606   argp2 = (Dali::Layer *)jarg2;
37607   if (!argp2) {
37608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37609     return ;
37610   }
37611   arg2 = *argp2;
37612   {
37613     try {
37614       (arg1)->LowerBelow(arg2);
37615     } catch (std::out_of_range& e) {
37616       {
37617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37618       };
37619     } catch (std::exception& e) {
37620       {
37621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37622       };
37623     } catch (Dali::DaliException e) {
37624       {
37625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37626       };
37627     } catch (...) {
37628       {
37629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37630       };
37631     }
37632   }
37633
37634 }
37635
37636
37637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37638   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37639
37640   arg1 = (Dali::Layer *)jarg1;
37641   {
37642     try {
37643       (arg1)->RaiseToTop();
37644     } catch (std::out_of_range& e) {
37645       {
37646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37647       };
37648     } catch (std::exception& e) {
37649       {
37650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37651       };
37652     } catch (Dali::DaliException e) {
37653       {
37654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37655       };
37656     } catch (...) {
37657       {
37658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37659       };
37660     }
37661   }
37662
37663 }
37664
37665
37666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37667   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37668
37669   arg1 = (Dali::Layer *)jarg1;
37670   {
37671     try {
37672       (arg1)->LowerToBottom();
37673     } catch (std::out_of_range& e) {
37674       {
37675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37676       };
37677     } catch (std::exception& e) {
37678       {
37679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37680       };
37681     } catch (Dali::DaliException e) {
37682       {
37683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37684       };
37685     } catch (...) {
37686       {
37687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37688       };
37689     }
37690   }
37691
37692 }
37693
37694
37695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37696   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37697   Dali::Layer arg2 ;
37698   Dali::Layer *argp2 ;
37699
37700   arg1 = (Dali::Layer *)jarg1;
37701   argp2 = (Dali::Layer *)jarg2;
37702   if (!argp2) {
37703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37704     return ;
37705   }
37706   arg2 = *argp2;
37707   {
37708     try {
37709       (arg1)->MoveAbove(arg2);
37710     } catch (std::out_of_range& e) {
37711       {
37712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37713       };
37714     } catch (std::exception& e) {
37715       {
37716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37717       };
37718     } catch (Dali::DaliException e) {
37719       {
37720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37721       };
37722     } catch (...) {
37723       {
37724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37725       };
37726     }
37727   }
37728
37729 }
37730
37731
37732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37733   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37734   Dali::Layer arg2 ;
37735   Dali::Layer *argp2 ;
37736
37737   arg1 = (Dali::Layer *)jarg1;
37738   argp2 = (Dali::Layer *)jarg2;
37739   if (!argp2) {
37740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37741     return ;
37742   }
37743   arg2 = *argp2;
37744   {
37745     try {
37746       (arg1)->MoveBelow(arg2);
37747     } catch (std::out_of_range& e) {
37748       {
37749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37750       };
37751     } catch (std::exception& e) {
37752       {
37753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37754       };
37755     } catch (Dali::DaliException e) {
37756       {
37757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37758       };
37759     } catch (...) {
37760       {
37761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37762       };
37763     }
37764   }
37765
37766 }
37767
37768
37769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37770   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37771   Dali::Layer::Behavior arg2 ;
37772
37773   arg1 = (Dali::Layer *)jarg1;
37774   arg2 = (Dali::Layer::Behavior)jarg2;
37775   {
37776     try {
37777       (arg1)->SetBehavior(arg2);
37778     } catch (std::out_of_range& e) {
37779       {
37780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37781       };
37782     } catch (std::exception& e) {
37783       {
37784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37785       };
37786     } catch (Dali::DaliException e) {
37787       {
37788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37789       };
37790     } catch (...) {
37791       {
37792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37793       };
37794     }
37795   }
37796
37797 }
37798
37799
37800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37801   int jresult ;
37802   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37803   Dali::Layer::Behavior result;
37804
37805   arg1 = (Dali::Layer *)jarg1;
37806   {
37807     try {
37808       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37809     } catch (std::out_of_range& e) {
37810       {
37811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37812       };
37813     } catch (std::exception& e) {
37814       {
37815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37816       };
37817     } catch (Dali::DaliException e) {
37818       {
37819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37820       };
37821     } catch (...) {
37822       {
37823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37824       };
37825     }
37826   }
37827
37828   jresult = (int)result;
37829   return jresult;
37830 }
37831
37832
37833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37834   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37835   bool arg2 ;
37836
37837   arg1 = (Dali::Layer *)jarg1;
37838   arg2 = jarg2 ? true : false;
37839   {
37840     try {
37841       (arg1)->SetClipping(arg2);
37842     } catch (std::out_of_range& e) {
37843       {
37844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37845       };
37846     } catch (std::exception& e) {
37847       {
37848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37849       };
37850     } catch (Dali::DaliException e) {
37851       {
37852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37853       };
37854     } catch (...) {
37855       {
37856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37857       };
37858     }
37859   }
37860
37861 }
37862
37863
37864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37865   unsigned int jresult ;
37866   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37867   bool result;
37868
37869   arg1 = (Dali::Layer *)jarg1;
37870   {
37871     try {
37872       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37873     } catch (std::out_of_range& e) {
37874       {
37875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37876       };
37877     } catch (std::exception& e) {
37878       {
37879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37880       };
37881     } catch (Dali::DaliException e) {
37882       {
37883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37884       };
37885     } catch (...) {
37886       {
37887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37888       };
37889     }
37890   }
37891
37892   jresult = result;
37893   return jresult;
37894 }
37895
37896
37897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37898   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37899   int arg2 ;
37900   int arg3 ;
37901   int arg4 ;
37902   int arg5 ;
37903
37904   arg1 = (Dali::Layer *)jarg1;
37905   arg2 = (int)jarg2;
37906   arg3 = (int)jarg3;
37907   arg4 = (int)jarg4;
37908   arg5 = (int)jarg5;
37909   {
37910     try {
37911       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37912     } catch (std::out_of_range& e) {
37913       {
37914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37915       };
37916     } catch (std::exception& e) {
37917       {
37918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37919       };
37920     } catch (Dali::DaliException e) {
37921       {
37922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37923       };
37924     } catch (...) {
37925       {
37926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37927       };
37928     }
37929   }
37930
37931 }
37932
37933
37934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37935   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37936   Dali::ClippingBox arg2 ;
37937   Dali::ClippingBox *argp2 ;
37938
37939   arg1 = (Dali::Layer *)jarg1;
37940   argp2 = (Dali::ClippingBox *)jarg2;
37941   if (!argp2) {
37942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37943     return ;
37944   }
37945   arg2 = *argp2;
37946   {
37947     try {
37948       (arg1)->SetClippingBox(arg2);
37949     } catch (std::out_of_range& e) {
37950       {
37951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37952       };
37953     } catch (std::exception& e) {
37954       {
37955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37956       };
37957     } catch (Dali::DaliException e) {
37958       {
37959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37960       };
37961     } catch (...) {
37962       {
37963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37964       };
37965     }
37966   }
37967
37968 }
37969
37970
37971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37972   void * jresult ;
37973   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37974   Dali::ClippingBox result;
37975
37976   arg1 = (Dali::Layer *)jarg1;
37977   {
37978     try {
37979       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37980     } catch (std::out_of_range& e) {
37981       {
37982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37983       };
37984     } catch (std::exception& e) {
37985       {
37986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37987       };
37988     } catch (Dali::DaliException e) {
37989       {
37990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37991       };
37992     } catch (...) {
37993       {
37994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37995       };
37996     }
37997   }
37998
37999   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38000   return jresult;
38001 }
38002
38003
38004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38005   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38006   bool arg2 ;
38007
38008   arg1 = (Dali::Layer *)jarg1;
38009   arg2 = jarg2 ? true : false;
38010   {
38011     try {
38012       (arg1)->SetDepthTestDisabled(arg2);
38013     } catch (std::out_of_range& e) {
38014       {
38015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38016       };
38017     } catch (std::exception& e) {
38018       {
38019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38020       };
38021     } catch (Dali::DaliException e) {
38022       {
38023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38024       };
38025     } catch (...) {
38026       {
38027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38028       };
38029     }
38030   }
38031
38032 }
38033
38034
38035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38036   unsigned int jresult ;
38037   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38038   bool result;
38039
38040   arg1 = (Dali::Layer *)jarg1;
38041   {
38042     try {
38043       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38044     } catch (std::out_of_range& e) {
38045       {
38046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38047       };
38048     } catch (std::exception& e) {
38049       {
38050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38051       };
38052     } catch (Dali::DaliException e) {
38053       {
38054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38055       };
38056     } catch (...) {
38057       {
38058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38059       };
38060     }
38061   }
38062
38063   jresult = result;
38064   return jresult;
38065 }
38066
38067
38068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38069   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38070   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38071
38072   arg1 = (Dali::Layer *)jarg1;
38073   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38074   {
38075     try {
38076       (arg1)->SetSortFunction(arg2);
38077     } catch (std::out_of_range& e) {
38078       {
38079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38080       };
38081     } catch (std::exception& e) {
38082       {
38083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38084       };
38085     } catch (Dali::DaliException e) {
38086       {
38087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38088       };
38089     } catch (...) {
38090       {
38091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38092       };
38093     }
38094   }
38095
38096 }
38097
38098
38099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38100   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38101   bool arg2 ;
38102
38103   arg1 = (Dali::Layer *)jarg1;
38104   arg2 = jarg2 ? true : false;
38105   {
38106     try {
38107       (arg1)->SetTouchConsumed(arg2);
38108     } catch (std::out_of_range& e) {
38109       {
38110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38111       };
38112     } catch (std::exception& e) {
38113       {
38114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38115       };
38116     } catch (Dali::DaliException e) {
38117       {
38118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38119       };
38120     } catch (...) {
38121       {
38122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38123       };
38124     }
38125   }
38126
38127 }
38128
38129
38130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38131   unsigned int jresult ;
38132   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38133   bool result;
38134
38135   arg1 = (Dali::Layer *)jarg1;
38136   {
38137     try {
38138       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38139     } catch (std::out_of_range& e) {
38140       {
38141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38142       };
38143     } catch (std::exception& e) {
38144       {
38145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38146       };
38147     } catch (Dali::DaliException e) {
38148       {
38149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38150       };
38151     } catch (...) {
38152       {
38153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38154       };
38155     }
38156   }
38157
38158   jresult = result;
38159   return jresult;
38160 }
38161
38162
38163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38164   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38165   bool arg2 ;
38166
38167   arg1 = (Dali::Layer *)jarg1;
38168   arg2 = jarg2 ? true : false;
38169   {
38170     try {
38171       (arg1)->SetHoverConsumed(arg2);
38172     } catch (std::out_of_range& e) {
38173       {
38174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38175       };
38176     } catch (std::exception& e) {
38177       {
38178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38179       };
38180     } catch (Dali::DaliException e) {
38181       {
38182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38183       };
38184     } catch (...) {
38185       {
38186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38187       };
38188     }
38189   }
38190
38191 }
38192
38193
38194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38195   unsigned int jresult ;
38196   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38197   bool result;
38198
38199   arg1 = (Dali::Layer *)jarg1;
38200   {
38201     try {
38202       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38203     } catch (std::out_of_range& e) {
38204       {
38205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38206       };
38207     } catch (std::exception& e) {
38208       {
38209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38210       };
38211     } catch (Dali::DaliException e) {
38212       {
38213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38214       };
38215     } catch (...) {
38216       {
38217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38218       };
38219     }
38220   }
38221
38222   jresult = result;
38223   return jresult;
38224 }
38225
38226
38227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38228   void * jresult ;
38229   Dali::Vector4 *result = 0 ;
38230
38231   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38232   jresult = (void *)result;
38233   return jresult;
38234 }
38235
38236
38237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38238   void * jresult ;
38239   Dali::Vector4 *result = 0 ;
38240
38241   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38242   jresult = (void *)result;
38243   return jresult;
38244 }
38245
38246
38247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38248   void * jresult ;
38249   Dali::Stage *result = 0 ;
38250
38251   {
38252     try {
38253       result = (Dali::Stage *)new Dali::Stage();
38254     } catch (std::out_of_range& e) {
38255       {
38256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38257       };
38258     } catch (std::exception& e) {
38259       {
38260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38261       };
38262     } catch (Dali::DaliException e) {
38263       {
38264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38265       };
38266     } catch (...) {
38267       {
38268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38269       };
38270     }
38271   }
38272
38273   jresult = (void *)result;
38274   return jresult;
38275 }
38276
38277
38278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38279   void * jresult ;
38280   Dali::Stage result;
38281
38282   {
38283     try {
38284       result = Dali::Stage::GetCurrent();
38285     } catch (std::out_of_range& e) {
38286       {
38287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38288       };
38289     } catch (std::exception& e) {
38290       {
38291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38292       };
38293     } catch (Dali::DaliException e) {
38294       {
38295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38296       };
38297     } catch (...) {
38298       {
38299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38300       };
38301     }
38302   }
38303
38304   jresult = new Dali::Stage((const Dali::Stage &)result);
38305   return jresult;
38306 }
38307
38308
38309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38310   unsigned int jresult ;
38311   bool result;
38312
38313   {
38314     try {
38315       result = (bool)Dali::Stage::IsInstalled();
38316     } catch (std::out_of_range& e) {
38317       {
38318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38319       };
38320     } catch (std::exception& e) {
38321       {
38322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38323       };
38324     } catch (Dali::DaliException e) {
38325       {
38326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38327       };
38328     } catch (...) {
38329       {
38330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38331       };
38332     }
38333   }
38334
38335   jresult = result;
38336   return jresult;
38337 }
38338
38339
38340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38341   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38342
38343   arg1 = (Dali::Stage *)jarg1;
38344   {
38345     try {
38346       delete arg1;
38347     } catch (std::out_of_range& e) {
38348       {
38349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38350       };
38351     } catch (std::exception& e) {
38352       {
38353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38354       };
38355     } catch (Dali::DaliException e) {
38356       {
38357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38358       };
38359     } catch (...) {
38360       {
38361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38362       };
38363     }
38364   }
38365
38366 }
38367
38368
38369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38370   void * jresult ;
38371   Dali::Stage *arg1 = 0 ;
38372   Dali::Stage *result = 0 ;
38373
38374   arg1 = (Dali::Stage *)jarg1;
38375   if (!arg1) {
38376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38377     return 0;
38378   }
38379   {
38380     try {
38381       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38382     } catch (std::out_of_range& e) {
38383       {
38384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38385       };
38386     } catch (std::exception& e) {
38387       {
38388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38389       };
38390     } catch (Dali::DaliException e) {
38391       {
38392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38393       };
38394     } catch (...) {
38395       {
38396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38397       };
38398     }
38399   }
38400
38401   jresult = (void *)result;
38402   return jresult;
38403 }
38404
38405
38406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38407   void * jresult ;
38408   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38409   Dali::Stage *arg2 = 0 ;
38410   Dali::Stage *result = 0 ;
38411
38412   arg1 = (Dali::Stage *)jarg1;
38413   arg2 = (Dali::Stage *)jarg2;
38414   if (!arg2) {
38415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38416     return 0;
38417   }
38418   {
38419     try {
38420       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38421     } catch (std::out_of_range& e) {
38422       {
38423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38424       };
38425     } catch (std::exception& e) {
38426       {
38427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38428       };
38429     } catch (Dali::DaliException e) {
38430       {
38431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38432       };
38433     } catch (...) {
38434       {
38435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38436       };
38437     }
38438   }
38439
38440   jresult = (void *)result;
38441   return jresult;
38442 }
38443
38444
38445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38446   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38447   Dali::Actor *arg2 = 0 ;
38448
38449   arg1 = (Dali::Stage *)jarg1;
38450   arg2 = (Dali::Actor *)jarg2;
38451   if (!arg2) {
38452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38453     return ;
38454   }
38455   {
38456     try {
38457       (arg1)->Add(*arg2);
38458     } catch (std::out_of_range& e) {
38459       {
38460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38461       };
38462     } catch (std::exception& e) {
38463       {
38464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38465       };
38466     } catch (Dali::DaliException e) {
38467       {
38468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38469       };
38470     } catch (...) {
38471       {
38472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38473       };
38474     }
38475   }
38476
38477 }
38478
38479
38480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38481   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38482   Dali::Actor *arg2 = 0 ;
38483
38484   arg1 = (Dali::Stage *)jarg1;
38485   arg2 = (Dali::Actor *)jarg2;
38486   if (!arg2) {
38487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38488     return ;
38489   }
38490   {
38491     try {
38492       (arg1)->Remove(*arg2);
38493     } catch (std::out_of_range& e) {
38494       {
38495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38496       };
38497     } catch (std::exception& e) {
38498       {
38499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38500       };
38501     } catch (Dali::DaliException e) {
38502       {
38503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38504       };
38505     } catch (...) {
38506       {
38507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38508       };
38509     }
38510   }
38511
38512 }
38513
38514
38515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38516   void * jresult ;
38517   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38518   Dali::Vector2 result;
38519
38520   arg1 = (Dali::Stage *)jarg1;
38521   {
38522     try {
38523       result = ((Dali::Stage const *)arg1)->GetSize();
38524     } catch (std::out_of_range& e) {
38525       {
38526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38527       };
38528     } catch (std::exception& e) {
38529       {
38530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38531       };
38532     } catch (Dali::DaliException e) {
38533       {
38534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38535       };
38536     } catch (...) {
38537       {
38538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38539       };
38540     }
38541   }
38542
38543   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38544   return jresult;
38545 }
38546
38547
38548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38549   void * jresult ;
38550   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38551   Dali::RenderTaskList result;
38552
38553   arg1 = (Dali::Stage *)jarg1;
38554   {
38555     try {
38556       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38557     } catch (std::out_of_range& e) {
38558       {
38559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38560       };
38561     } catch (std::exception& e) {
38562       {
38563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38564       };
38565     } catch (Dali::DaliException e) {
38566       {
38567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38568       };
38569     } catch (...) {
38570       {
38571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38572       };
38573     }
38574   }
38575
38576   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38577   return jresult;
38578 }
38579
38580
38581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38582   unsigned int jresult ;
38583   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38584   unsigned int result;
38585
38586   arg1 = (Dali::Stage *)jarg1;
38587   {
38588     try {
38589       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38590     } catch (std::out_of_range& e) {
38591       {
38592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38593       };
38594     } catch (std::exception& e) {
38595       {
38596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38597       };
38598     } catch (Dali::DaliException e) {
38599       {
38600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38601       };
38602     } catch (...) {
38603       {
38604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38605       };
38606     }
38607   }
38608
38609   jresult = result;
38610   return jresult;
38611 }
38612
38613
38614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38615   void * jresult ;
38616   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38617   unsigned int arg2 ;
38618   Dali::Layer result;
38619
38620   arg1 = (Dali::Stage *)jarg1;
38621   arg2 = (unsigned int)jarg2;
38622   {
38623     try {
38624       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38625     } catch (std::out_of_range& e) {
38626       {
38627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38628       };
38629     } catch (std::exception& e) {
38630       {
38631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38632       };
38633     } catch (Dali::DaliException e) {
38634       {
38635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38636       };
38637     } catch (...) {
38638       {
38639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38640       };
38641     }
38642   }
38643
38644   jresult = new Dali::Layer((const Dali::Layer &)result);
38645   return jresult;
38646 }
38647
38648
38649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38650   void * jresult ;
38651   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38652   Dali::Layer result;
38653
38654   arg1 = (Dali::Stage *)jarg1;
38655   {
38656     try {
38657       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38658     } catch (std::out_of_range& e) {
38659       {
38660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38661       };
38662     } catch (std::exception& e) {
38663       {
38664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38665       };
38666     } catch (Dali::DaliException e) {
38667       {
38668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38669       };
38670     } catch (...) {
38671       {
38672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38673       };
38674     }
38675   }
38676
38677   jresult = new Dali::Layer((const Dali::Layer &)result);
38678   return jresult;
38679 }
38680
38681
38682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38683   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38684   Dali::Vector4 arg2 ;
38685   Dali::Vector4 *argp2 ;
38686
38687   arg1 = (Dali::Stage *)jarg1;
38688   argp2 = (Dali::Vector4 *)jarg2;
38689   if (!argp2) {
38690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38691     return ;
38692   }
38693   arg2 = *argp2;
38694   {
38695     try {
38696       (arg1)->SetBackgroundColor(arg2);
38697     } catch (std::out_of_range& e) {
38698       {
38699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38700       };
38701     } catch (std::exception& e) {
38702       {
38703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38704       };
38705     } catch (Dali::DaliException e) {
38706       {
38707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38708       };
38709     } catch (...) {
38710       {
38711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38712       };
38713     }
38714   }
38715
38716 }
38717
38718
38719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38720   void * jresult ;
38721   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38722   Dali::Vector4 result;
38723
38724   arg1 = (Dali::Stage *)jarg1;
38725   {
38726     try {
38727       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38728     } catch (std::out_of_range& e) {
38729       {
38730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38731       };
38732     } catch (std::exception& e) {
38733       {
38734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38735       };
38736     } catch (Dali::DaliException e) {
38737       {
38738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38739       };
38740     } catch (...) {
38741       {
38742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38743       };
38744     }
38745   }
38746
38747   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38748   return jresult;
38749 }
38750
38751
38752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38753   void * jresult ;
38754   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38755   Dali::Vector2 result;
38756
38757   arg1 = (Dali::Stage *)jarg1;
38758   {
38759     try {
38760       result = ((Dali::Stage const *)arg1)->GetDpi();
38761     } catch (std::out_of_range& e) {
38762       {
38763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38764       };
38765     } catch (std::exception& e) {
38766       {
38767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38768       };
38769     } catch (Dali::DaliException e) {
38770       {
38771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38772       };
38773     } catch (...) {
38774       {
38775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38776       };
38777     }
38778   }
38779
38780   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38781   return jresult;
38782 }
38783
38784
38785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38786   void * jresult ;
38787   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38788   Dali::ObjectRegistry result;
38789
38790   arg1 = (Dali::Stage *)jarg1;
38791   {
38792     try {
38793       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38794     } catch (std::out_of_range& e) {
38795       {
38796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38797       };
38798     } catch (std::exception& e) {
38799       {
38800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38801       };
38802     } catch (Dali::DaliException e) {
38803       {
38804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38805       };
38806     } catch (...) {
38807       {
38808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38809       };
38810     }
38811   }
38812
38813   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38814   return jresult;
38815 }
38816
38817
38818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38819   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38820   float arg2 ;
38821
38822   arg1 = (Dali::Stage *)jarg1;
38823   arg2 = (float)jarg2;
38824   {
38825     try {
38826       (arg1)->KeepRendering(arg2);
38827     } catch (std::out_of_range& e) {
38828       {
38829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38830       };
38831     } catch (std::exception& e) {
38832       {
38833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38834       };
38835     } catch (Dali::DaliException e) {
38836       {
38837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38838       };
38839     } catch (...) {
38840       {
38841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38842       };
38843     }
38844   }
38845
38846 }
38847
38848
38849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38850   void * jresult ;
38851   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38852   Dali::Stage::KeyEventSignalType *result = 0 ;
38853
38854   arg1 = (Dali::Stage *)jarg1;
38855   {
38856     try {
38857       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38858     } catch (std::out_of_range& e) {
38859       {
38860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38861       };
38862     } catch (std::exception& e) {
38863       {
38864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38865       };
38866     } catch (Dali::DaliException e) {
38867       {
38868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38869       };
38870     } catch (...) {
38871       {
38872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38873       };
38874     }
38875   }
38876
38877   jresult = (void *)result;
38878   return jresult;
38879 }
38880
38881
38882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38883   void * jresult ;
38884   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38885   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38886
38887   arg1 = (Dali::Stage *)jarg1;
38888   {
38889     try {
38890       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38891     } catch (std::out_of_range& e) {
38892       {
38893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38894       };
38895     } catch (std::exception& e) {
38896       {
38897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38898       };
38899     } catch (Dali::DaliException e) {
38900       {
38901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38902       };
38903     } catch (...) {
38904       {
38905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38906       };
38907     }
38908   }
38909
38910   jresult = (void *)result;
38911   return jresult;
38912 }
38913
38914
38915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38916   void * jresult ;
38917   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38918   Dali::Stage::TouchSignalType *result = 0 ;
38919
38920   arg1 = (Dali::Stage *)jarg1;
38921   {
38922     try {
38923       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38924     } catch (std::out_of_range& e) {
38925       {
38926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38927       };
38928     } catch (std::exception& e) {
38929       {
38930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38931       };
38932     } catch (Dali::DaliException e) {
38933       {
38934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38935       };
38936     } catch (...) {
38937       {
38938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38939       };
38940     }
38941   }
38942
38943   jresult = (void *)result;
38944   return jresult;
38945 }
38946
38947
38948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38949   void * jresult ;
38950   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38951   Dali::Stage::WheelEventSignalType *result = 0 ;
38952
38953   arg1 = (Dali::Stage *)jarg1;
38954   {
38955     try {
38956       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38957     } catch (std::out_of_range& e) {
38958       {
38959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38960       };
38961     } catch (std::exception& e) {
38962       {
38963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38964       };
38965     } catch (Dali::DaliException e) {
38966       {
38967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38968       };
38969     } catch (...) {
38970       {
38971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38972       };
38973     }
38974   }
38975
38976   jresult = (void *)result;
38977   return jresult;
38978 }
38979
38980
38981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38982   void * jresult ;
38983   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38984   Dali::Stage::ContextStatusSignal *result = 0 ;
38985
38986   arg1 = (Dali::Stage *)jarg1;
38987   {
38988     try {
38989       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38990     } catch (std::out_of_range& e) {
38991       {
38992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38993       };
38994     } catch (std::exception& e) {
38995       {
38996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38997       };
38998     } catch (Dali::DaliException e) {
38999       {
39000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39001       };
39002     } catch (...) {
39003       {
39004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39005       };
39006     }
39007   }
39008
39009   jresult = (void *)result;
39010   return jresult;
39011 }
39012
39013
39014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39015   void * jresult ;
39016   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39017   Dali::Stage::ContextStatusSignal *result = 0 ;
39018
39019   arg1 = (Dali::Stage *)jarg1;
39020   {
39021     try {
39022       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39023     } catch (std::out_of_range& e) {
39024       {
39025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39026       };
39027     } catch (std::exception& e) {
39028       {
39029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39030       };
39031     } catch (Dali::DaliException e) {
39032       {
39033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39034       };
39035     } catch (...) {
39036       {
39037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39038       };
39039     }
39040   }
39041
39042   jresult = (void *)result;
39043   return jresult;
39044 }
39045
39046
39047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39048   void * jresult ;
39049   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39050   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39051
39052   arg1 = (Dali::Stage *)jarg1;
39053   {
39054     try {
39055       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39056     } catch (std::out_of_range& e) {
39057       {
39058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39059       };
39060     } catch (std::exception& e) {
39061       {
39062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39063       };
39064     } catch (Dali::DaliException e) {
39065       {
39066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39067       };
39068     } catch (...) {
39069       {
39070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39071       };
39072     }
39073   }
39074
39075   jresult = (void *)result;
39076   return jresult;
39077 }
39078
39079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39080   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39081   Dali::DevelStage::Rendering arg2 ;
39082
39083   arg1 = (Dali::Stage *)jarg1;
39084   arg2 = (Dali::DevelStage::Rendering)jarg2;
39085   {
39086     try {
39087       DevelStage::SetRenderingBehavior(*arg1,arg2);
39088     } catch (std::out_of_range& e) {
39089       {
39090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39091       };
39092     } catch (std::exception& e) {
39093       {
39094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39095       };
39096     } catch (Dali::DaliException e) {
39097       {
39098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39099       };
39100     } catch (...) {
39101       {
39102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39103       };
39104     }
39105   }
39106
39107 }
39108
39109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39110
39111   int jresult ;
39112   int result ;
39113   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39114
39115   arg1 = (Dali::Stage *)jarg1;
39116   {
39117     try {
39118       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39119     } catch (std::out_of_range& e) {
39120       {
39121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39122       };
39123     } catch (std::exception& e) {
39124       {
39125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39126       };
39127     } catch (Dali::DaliException e) {
39128       {
39129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39130       };
39131     } catch (...) {
39132       {
39133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39134       };
39135     }
39136   }
39137
39138   jresult = result;
39139   return jresult;
39140 }
39141
39142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39143   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39144
39145   arg1 = (Dali::RelayoutContainer *)jarg1;
39146   {
39147     try {
39148       delete arg1;
39149     } catch (std::out_of_range& e) {
39150       {
39151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39152       };
39153     } catch (std::exception& e) {
39154       {
39155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39156       };
39157     } catch (Dali::DaliException e) {
39158       {
39159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39160       };
39161     } catch (...) {
39162       {
39163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39164       };
39165     }
39166   }
39167
39168 }
39169
39170
39171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39172   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39173   Dali::Actor *arg2 = 0 ;
39174   Dali::Vector2 *arg3 = 0 ;
39175
39176   arg1 = (Dali::RelayoutContainer *)jarg1;
39177   arg2 = (Dali::Actor *)jarg2;
39178   if (!arg2) {
39179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39180     return ;
39181   }
39182   arg3 = (Dali::Vector2 *)jarg3;
39183   if (!arg3) {
39184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39185     return ;
39186   }
39187   {
39188     try {
39189       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39190     } catch (std::out_of_range& e) {
39191       {
39192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39193       };
39194     } catch (std::exception& e) {
39195       {
39196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39197       };
39198     } catch (Dali::DaliException e) {
39199       {
39200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39201       };
39202     } catch (...) {
39203       {
39204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39205       };
39206     }
39207   }
39208
39209 }
39210
39211
39212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39213   void * jresult ;
39214   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39215   Dali::CustomActor result;
39216
39217   arg1 = (Dali::CustomActorImpl *)jarg1;
39218   {
39219     try {
39220       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39221     } catch (std::out_of_range& e) {
39222       {
39223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39224       };
39225     } catch (std::exception& e) {
39226       {
39227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39228       };
39229     } catch (Dali::DaliException e) {
39230       {
39231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39232       };
39233     } catch (...) {
39234       {
39235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39236       };
39237     }
39238   }
39239
39240   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39241   return jresult;
39242 }
39243
39244
39245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39246   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39247   int arg2 ;
39248
39249   arg1 = (Dali::CustomActorImpl *)jarg1;
39250   arg2 = (int)jarg2;
39251   {
39252     try {
39253       (arg1)->OnStageConnection(arg2);
39254     } catch (std::out_of_range& e) {
39255       {
39256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39257       };
39258     } catch (std::exception& e) {
39259       {
39260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39261       };
39262     } catch (Dali::DaliException e) {
39263       {
39264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39265       };
39266     } catch (...) {
39267       {
39268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39269       };
39270     }
39271   }
39272
39273 }
39274
39275
39276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39277   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39278
39279   arg1 = (Dali::CustomActorImpl *)jarg1;
39280   {
39281     try {
39282       (arg1)->OnStageDisconnection();
39283     } catch (std::out_of_range& e) {
39284       {
39285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39286       };
39287     } catch (std::exception& e) {
39288       {
39289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39290       };
39291     } catch (Dali::DaliException e) {
39292       {
39293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39294       };
39295     } catch (...) {
39296       {
39297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39298       };
39299     }
39300   }
39301
39302 }
39303
39304
39305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39306   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39307   Dali::Actor *arg2 = 0 ;
39308
39309   arg1 = (Dali::CustomActorImpl *)jarg1;
39310   arg2 = (Dali::Actor *)jarg2;
39311   if (!arg2) {
39312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39313     return ;
39314   }
39315   {
39316     try {
39317       (arg1)->OnChildAdd(*arg2);
39318     } catch (std::out_of_range& e) {
39319       {
39320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39321       };
39322     } catch (std::exception& e) {
39323       {
39324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39325       };
39326     } catch (Dali::DaliException e) {
39327       {
39328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39329       };
39330     } catch (...) {
39331       {
39332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39333       };
39334     }
39335   }
39336
39337 }
39338
39339
39340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39341   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39342   Dali::Actor *arg2 = 0 ;
39343
39344   arg1 = (Dali::CustomActorImpl *)jarg1;
39345   arg2 = (Dali::Actor *)jarg2;
39346   if (!arg2) {
39347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39348     return ;
39349   }
39350   {
39351     try {
39352       (arg1)->OnChildRemove(*arg2);
39353     } catch (std::out_of_range& e) {
39354       {
39355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39356       };
39357     } catch (std::exception& e) {
39358       {
39359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39360       };
39361     } catch (Dali::DaliException e) {
39362       {
39363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39364       };
39365     } catch (...) {
39366       {
39367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39368       };
39369     }
39370   }
39371
39372 }
39373
39374
39375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39376   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39377   Dali::Property::Index arg2 ;
39378   Dali::Property::Value arg3 ;
39379   Dali::Property::Value *argp3 ;
39380
39381   arg1 = (Dali::CustomActorImpl *)jarg1;
39382   arg2 = (Dali::Property::Index)jarg2;
39383   argp3 = (Dali::Property::Value *)jarg3;
39384   if (!argp3) {
39385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39386     return ;
39387   }
39388   arg3 = *argp3;
39389   {
39390     try {
39391       (arg1)->OnPropertySet(arg2,arg3);
39392     } catch (std::out_of_range& e) {
39393       {
39394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39395       };
39396     } catch (std::exception& e) {
39397       {
39398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39399       };
39400     } catch (Dali::DaliException e) {
39401       {
39402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39403       };
39404     } catch (...) {
39405       {
39406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39407       };
39408     }
39409   }
39410
39411 }
39412
39413
39414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39415   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39416   Dali::Vector3 *arg2 = 0 ;
39417
39418   arg1 = (Dali::CustomActorImpl *)jarg1;
39419   arg2 = (Dali::Vector3 *)jarg2;
39420   if (!arg2) {
39421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39422     return ;
39423   }
39424   {
39425     try {
39426       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39427     } catch (std::out_of_range& e) {
39428       {
39429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39430       };
39431     } catch (std::exception& e) {
39432       {
39433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39434       };
39435     } catch (Dali::DaliException e) {
39436       {
39437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39438       };
39439     } catch (...) {
39440       {
39441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39442       };
39443     }
39444   }
39445
39446 }
39447
39448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39449   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39450   Dali::Animation *arg2 = 0 ;
39451   Dali::Vector3 *arg3 = 0 ;
39452
39453   arg1 = (Dali::CustomActorImpl *)jarg1;
39454   arg2 = (Dali::Animation *)jarg2;
39455   if (!arg2) {
39456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39457     return ;
39458   }
39459   arg3 = (Dali::Vector3 *)jarg3;
39460   if (!arg3) {
39461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39462     return ;
39463   }
39464   {
39465     try {
39466       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
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 unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39490   unsigned int jresult ;
39491   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39492   Dali::TouchEvent *arg2 = 0 ;
39493   bool result;
39494
39495   arg1 = (Dali::CustomActorImpl *)jarg1;
39496   arg2 = (Dali::TouchEvent *)jarg2;
39497   if (!arg2) {
39498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39499     return 0;
39500   }
39501   {
39502     try {
39503       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39504     } catch (std::out_of_range& e) {
39505       {
39506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39507       };
39508     } catch (std::exception& e) {
39509       {
39510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39511       };
39512     } catch (Dali::DaliException e) {
39513       {
39514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39515       };
39516     } catch (...) {
39517       {
39518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39519       };
39520     }
39521   }
39522
39523   jresult = result;
39524   return jresult;
39525 }
39526
39527
39528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39529   unsigned int jresult ;
39530   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39531   Dali::HoverEvent *arg2 = 0 ;
39532   bool result;
39533
39534   arg1 = (Dali::CustomActorImpl *)jarg1;
39535   arg2 = (Dali::HoverEvent *)jarg2;
39536   if (!arg2) {
39537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39538     return 0;
39539   }
39540   {
39541     try {
39542       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39543     } catch (std::out_of_range& e) {
39544       {
39545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39546       };
39547     } catch (std::exception& e) {
39548       {
39549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39550       };
39551     } catch (Dali::DaliException e) {
39552       {
39553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39554       };
39555     } catch (...) {
39556       {
39557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39558       };
39559     }
39560   }
39561
39562   jresult = result;
39563   return jresult;
39564 }
39565
39566
39567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39568   unsigned int jresult ;
39569   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39570   Dali::KeyEvent *arg2 = 0 ;
39571   bool result;
39572
39573   arg1 = (Dali::CustomActorImpl *)jarg1;
39574   arg2 = (Dali::KeyEvent *)jarg2;
39575   if (!arg2) {
39576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39577     return 0;
39578   }
39579   {
39580     try {
39581       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39582     } catch (std::out_of_range& e) {
39583       {
39584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39585       };
39586     } catch (std::exception& e) {
39587       {
39588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39589       };
39590     } catch (Dali::DaliException e) {
39591       {
39592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39593       };
39594     } catch (...) {
39595       {
39596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39597       };
39598     }
39599   }
39600
39601   jresult = result;
39602   return jresult;
39603 }
39604
39605
39606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39607   unsigned int jresult ;
39608   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39609   Dali::WheelEvent *arg2 = 0 ;
39610   bool result;
39611
39612   arg1 = (Dali::CustomActorImpl *)jarg1;
39613   arg2 = (Dali::WheelEvent *)jarg2;
39614   if (!arg2) {
39615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39616     return 0;
39617   }
39618   {
39619     try {
39620       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39621     } catch (std::out_of_range& e) {
39622       {
39623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39624       };
39625     } catch (std::exception& e) {
39626       {
39627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39628       };
39629     } catch (Dali::DaliException e) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39632       };
39633     } catch (...) {
39634       {
39635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39636       };
39637     }
39638   }
39639
39640   jresult = result;
39641   return jresult;
39642 }
39643
39644
39645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39646   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39647   Dali::Vector2 *arg2 = 0 ;
39648   Dali::RelayoutContainer *arg3 = 0 ;
39649
39650   arg1 = (Dali::CustomActorImpl *)jarg1;
39651   arg2 = (Dali::Vector2 *)jarg2;
39652   if (!arg2) {
39653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39654     return ;
39655   }
39656   arg3 = (Dali::RelayoutContainer *)jarg3;
39657   if (!arg3) {
39658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39659     return ;
39660   }
39661   {
39662     try {
39663       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39664     } catch (std::out_of_range& e) {
39665       {
39666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39667       };
39668     } catch (std::exception& e) {
39669       {
39670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39671       };
39672     } catch (Dali::DaliException e) {
39673       {
39674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39675       };
39676     } catch (...) {
39677       {
39678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39679       };
39680     }
39681   }
39682
39683 }
39684
39685
39686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39687   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39688   Dali::ResizePolicy::Type arg2 ;
39689   Dali::Dimension::Type arg3 ;
39690
39691   arg1 = (Dali::CustomActorImpl *)jarg1;
39692   arg2 = (Dali::ResizePolicy::Type)jarg2;
39693   arg3 = (Dali::Dimension::Type)jarg3;
39694   {
39695     try {
39696       (arg1)->OnSetResizePolicy(arg2,arg3);
39697     } catch (std::out_of_range& e) {
39698       {
39699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39700       };
39701     } catch (std::exception& e) {
39702       {
39703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39704       };
39705     } catch (Dali::DaliException e) {
39706       {
39707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39708       };
39709     } catch (...) {
39710       {
39711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39712       };
39713     }
39714   }
39715
39716 }
39717
39718
39719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39720   void * jresult ;
39721   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39722   Dali::Vector3 result;
39723
39724   arg1 = (Dali::CustomActorImpl *)jarg1;
39725   {
39726     try {
39727       result = (arg1)->GetNaturalSize();
39728     } catch (std::out_of_range& e) {
39729       {
39730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39731       };
39732     } catch (std::exception& e) {
39733       {
39734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39735       };
39736     } catch (Dali::DaliException e) {
39737       {
39738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39739       };
39740     } catch (...) {
39741       {
39742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39743       };
39744     }
39745   }
39746
39747   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39748   return jresult;
39749 }
39750
39751
39752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39753   float jresult ;
39754   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39755   Dali::Actor *arg2 = 0 ;
39756   Dali::Dimension::Type arg3 ;
39757   float result;
39758
39759   arg1 = (Dali::CustomActorImpl *)jarg1;
39760   arg2 = (Dali::Actor *)jarg2;
39761   if (!arg2) {
39762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39763     return 0;
39764   }
39765   arg3 = (Dali::Dimension::Type)jarg3;
39766   {
39767     try {
39768       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39769     } catch (std::out_of_range& e) {
39770       {
39771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39772       };
39773     } catch (std::exception& e) {
39774       {
39775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39776       };
39777     } catch (Dali::DaliException e) {
39778       {
39779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39780       };
39781     } catch (...) {
39782       {
39783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39784       };
39785     }
39786   }
39787
39788   jresult = result;
39789   return jresult;
39790 }
39791
39792
39793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39794   float jresult ;
39795   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39796   float arg2 ;
39797   float result;
39798
39799   arg1 = (Dali::CustomActorImpl *)jarg1;
39800   arg2 = (float)jarg2;
39801   {
39802     try {
39803       result = (float)(arg1)->GetHeightForWidth(arg2);
39804     } catch (std::out_of_range& e) {
39805       {
39806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39807       };
39808     } catch (std::exception& e) {
39809       {
39810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39811       };
39812     } catch (Dali::DaliException e) {
39813       {
39814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39815       };
39816     } catch (...) {
39817       {
39818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39819       };
39820     }
39821   }
39822
39823   jresult = result;
39824   return jresult;
39825 }
39826
39827
39828 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39829   float jresult ;
39830   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39831   float arg2 ;
39832   float result;
39833
39834   arg1 = (Dali::CustomActorImpl *)jarg1;
39835   arg2 = (float)jarg2;
39836   {
39837     try {
39838       result = (float)(arg1)->GetWidthForHeight(arg2);
39839     } catch (std::out_of_range& e) {
39840       {
39841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39842       };
39843     } catch (std::exception& e) {
39844       {
39845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39846       };
39847     } catch (Dali::DaliException e) {
39848       {
39849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39850       };
39851     } catch (...) {
39852       {
39853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39854       };
39855     }
39856   }
39857
39858   jresult = result;
39859   return jresult;
39860 }
39861
39862
39863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39864   unsigned int jresult ;
39865   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39866   Dali::Dimension::Type arg2 ;
39867   bool result;
39868
39869   arg1 = (Dali::CustomActorImpl *)jarg1;
39870   arg2 = (Dali::Dimension::Type)jarg2;
39871   {
39872     try {
39873       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39874     } catch (std::out_of_range& e) {
39875       {
39876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39877       };
39878     } catch (std::exception& e) {
39879       {
39880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39881       };
39882     } catch (Dali::DaliException e) {
39883       {
39884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39885       };
39886     } catch (...) {
39887       {
39888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39889       };
39890     }
39891   }
39892
39893   jresult = result;
39894   return jresult;
39895 }
39896
39897
39898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39899   unsigned int jresult ;
39900   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39901   bool result;
39902
39903   arg1 = (Dali::CustomActorImpl *)jarg1;
39904   {
39905     try {
39906       result = (bool)(arg1)->RelayoutDependentOnChildren();
39907     } catch (std::out_of_range& e) {
39908       {
39909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39910       };
39911     } catch (std::exception& e) {
39912       {
39913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39914       };
39915     } catch (Dali::DaliException e) {
39916       {
39917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39918       };
39919     } catch (...) {
39920       {
39921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39922       };
39923     }
39924   }
39925
39926   jresult = result;
39927   return jresult;
39928 }
39929
39930
39931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39932   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39933   Dali::Dimension::Type arg2 ;
39934
39935   arg1 = (Dali::CustomActorImpl *)jarg1;
39936   arg2 = (Dali::Dimension::Type)jarg2;
39937   {
39938     try {
39939       (arg1)->OnCalculateRelayoutSize(arg2);
39940     } catch (std::out_of_range& e) {
39941       {
39942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39943       };
39944     } catch (std::exception& e) {
39945       {
39946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39947       };
39948     } catch (Dali::DaliException e) {
39949       {
39950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39951       };
39952     } catch (...) {
39953       {
39954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39955       };
39956     }
39957   }
39958
39959 }
39960
39961
39962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39963   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39964   float arg2 ;
39965   Dali::Dimension::Type arg3 ;
39966
39967   arg1 = (Dali::CustomActorImpl *)jarg1;
39968   arg2 = (float)jarg2;
39969   arg3 = (Dali::Dimension::Type)jarg3;
39970   {
39971     try {
39972       (arg1)->OnLayoutNegotiated(arg2,arg3);
39973     } catch (std::out_of_range& e) {
39974       {
39975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39976       };
39977     } catch (std::exception& e) {
39978       {
39979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39980       };
39981     } catch (Dali::DaliException e) {
39982       {
39983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39984       };
39985     } catch (...) {
39986       {
39987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39988       };
39989     }
39990   }
39991
39992 }
39993
39994
39995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39996   unsigned int jresult ;
39997   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39998   bool result;
39999
40000   arg1 = (Dali::CustomActorImpl *)jarg1;
40001   {
40002     try {
40003       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40004     } catch (std::out_of_range& e) {
40005       {
40006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40007       };
40008     } catch (std::exception& e) {
40009       {
40010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40011       };
40012     } catch (Dali::DaliException e) {
40013       {
40014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40015       };
40016     } catch (...) {
40017       {
40018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40019       };
40020     }
40021   }
40022
40023   jresult = result;
40024   return jresult;
40025 }
40026
40027
40028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40029   unsigned int jresult ;
40030   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40031   bool result;
40032
40033   arg1 = (Dali::CustomActorImpl *)jarg1;
40034   {
40035     try {
40036       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40037     } catch (std::out_of_range& e) {
40038       {
40039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40040       };
40041     } catch (std::exception& e) {
40042       {
40043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40044       };
40045     } catch (Dali::DaliException e) {
40046       {
40047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40048       };
40049     } catch (...) {
40050       {
40051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40052       };
40053     }
40054   }
40055
40056   jresult = result;
40057   return jresult;
40058 }
40059
40060
40061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40062   unsigned int jresult ;
40063   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40064   bool result;
40065
40066   arg1 = (Dali::CustomActorImpl *)jarg1;
40067   {
40068     try {
40069       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40070     } catch (std::out_of_range& e) {
40071       {
40072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40073       };
40074     } catch (std::exception& e) {
40075       {
40076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40077       };
40078     } catch (Dali::DaliException e) {
40079       {
40080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40081       };
40082     } catch (...) {
40083       {
40084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40085       };
40086     }
40087   }
40088
40089   jresult = result;
40090   return jresult;
40091 }
40092
40093
40094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40095   unsigned int jresult ;
40096   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40097   bool result;
40098
40099   arg1 = (Dali::CustomActorImpl *)jarg1;
40100   {
40101     try {
40102       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40103     } catch (std::out_of_range& e) {
40104       {
40105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40106       };
40107     } catch (std::exception& e) {
40108       {
40109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40110       };
40111     } catch (Dali::DaliException e) {
40112       {
40113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40114       };
40115     } catch (...) {
40116       {
40117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40118       };
40119     }
40120   }
40121
40122   jresult = result;
40123   return jresult;
40124 }
40125
40126
40127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40128   void * jresult ;
40129   Dali::CustomActor *result = 0 ;
40130
40131   {
40132     try {
40133       result = (Dali::CustomActor *)new Dali::CustomActor();
40134     } catch (std::out_of_range& e) {
40135       {
40136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40137       };
40138     } catch (std::exception& e) {
40139       {
40140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40141       };
40142     } catch (Dali::DaliException e) {
40143       {
40144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40145       };
40146     } catch (...) {
40147       {
40148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40149       };
40150     }
40151   }
40152
40153   jresult = (void *)result;
40154   return jresult;
40155 }
40156
40157
40158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40159   void * jresult ;
40160   Dali::BaseHandle arg1 ;
40161   Dali::BaseHandle *argp1 ;
40162   Dali::CustomActor result;
40163
40164   argp1 = (Dali::BaseHandle *)jarg1;
40165   if (!argp1) {
40166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40167     return 0;
40168   }
40169   arg1 = *argp1;
40170   {
40171     try {
40172       result = Dali::CustomActor::DownCast(arg1);
40173     } catch (std::out_of_range& e) {
40174       {
40175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40176       };
40177     } catch (std::exception& e) {
40178       {
40179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40180       };
40181     } catch (Dali::DaliException e) {
40182       {
40183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40184       };
40185     } catch (...) {
40186       {
40187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40188       };
40189     }
40190   }
40191
40192   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40193   return jresult;
40194 }
40195
40196
40197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40198   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40199
40200   arg1 = (Dali::CustomActor *)jarg1;
40201   {
40202     try {
40203       delete arg1;
40204     } catch (std::out_of_range& e) {
40205       {
40206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40207       };
40208     } catch (std::exception& e) {
40209       {
40210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40211       };
40212     } catch (Dali::DaliException e) {
40213       {
40214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40215       };
40216     } catch (...) {
40217       {
40218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40219       };
40220     }
40221   }
40222
40223 }
40224
40225
40226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40227   void * jresult ;
40228   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40229   Dali::CustomActorImpl *result = 0 ;
40230
40231   arg1 = (Dali::CustomActor *)jarg1;
40232   {
40233     try {
40234       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40235     } catch (std::out_of_range& e) {
40236       {
40237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40238       };
40239     } catch (std::exception& e) {
40240       {
40241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40242       };
40243     } catch (Dali::DaliException e) {
40244       {
40245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40246       };
40247     } catch (...) {
40248       {
40249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40250       };
40251     }
40252   }
40253
40254   jresult = (void *)result;
40255   return jresult;
40256 }
40257
40258
40259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40260   void * jresult ;
40261   Dali::CustomActorImpl *arg1 = 0 ;
40262   Dali::CustomActor *result = 0 ;
40263
40264   arg1 = (Dali::CustomActorImpl *)jarg1;
40265   if (!arg1) {
40266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40267     return 0;
40268   }
40269   {
40270     try {
40271       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40272     } catch (std::out_of_range& e) {
40273       {
40274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40275       };
40276     } catch (std::exception& e) {
40277       {
40278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40279       };
40280     } catch (Dali::DaliException e) {
40281       {
40282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40283       };
40284     } catch (...) {
40285       {
40286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40287       };
40288     }
40289   }
40290
40291   jresult = (void *)result;
40292   return jresult;
40293 }
40294
40295
40296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40297   void * jresult ;
40298   Dali::CustomActor *arg1 = 0 ;
40299   Dali::CustomActor *result = 0 ;
40300
40301   arg1 = (Dali::CustomActor *)jarg1;
40302   if (!arg1) {
40303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40304     return 0;
40305   }
40306   {
40307     try {
40308       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40309     } catch (std::out_of_range& e) {
40310       {
40311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40312       };
40313     } catch (std::exception& e) {
40314       {
40315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40316       };
40317     } catch (Dali::DaliException e) {
40318       {
40319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40320       };
40321     } catch (...) {
40322       {
40323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40324       };
40325     }
40326   }
40327
40328   jresult = (void *)result;
40329   return jresult;
40330 }
40331
40332
40333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40334   void * jresult ;
40335   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40336   Dali::CustomActor *arg2 = 0 ;
40337   Dali::CustomActor *result = 0 ;
40338
40339   arg1 = (Dali::CustomActor *)jarg1;
40340   arg2 = (Dali::CustomActor *)jarg2;
40341   if (!arg2) {
40342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40343     return 0;
40344   }
40345   {
40346     try {
40347       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40348     } catch (std::out_of_range& e) {
40349       {
40350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40351       };
40352     } catch (std::exception& e) {
40353       {
40354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40355       };
40356     } catch (Dali::DaliException e) {
40357       {
40358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40359       };
40360     } catch (...) {
40361       {
40362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40363       };
40364     }
40365   }
40366
40367   jresult = (void *)result;
40368   return jresult;
40369 }
40370
40371
40372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40373   int jresult ;
40374   int result;
40375
40376   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40377   jresult = (int)result;
40378   return jresult;
40379 }
40380
40381
40382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40383   int jresult ;
40384   int result;
40385
40386   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40387   jresult = (int)result;
40388   return jresult;
40389 }
40390
40391
40392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40393   int jresult ;
40394   int result;
40395
40396   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40397   jresult = (int)result;
40398   return jresult;
40399 }
40400
40401
40402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40403   int jresult ;
40404   int result;
40405
40406   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40407   jresult = (int)result;
40408   return jresult;
40409 }
40410
40411
40412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40413   int jresult ;
40414   int result;
40415
40416   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40417   jresult = (int)result;
40418   return jresult;
40419 }
40420
40421
40422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40423   int jresult ;
40424   int result;
40425
40426   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40427   jresult = (int)result;
40428   return jresult;
40429 }
40430
40431
40432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40433   int jresult ;
40434   int result;
40435
40436   result = (int)Dali::PanGestureDetector::Property::PANNING;
40437   jresult = (int)result;
40438   return jresult;
40439 }
40440
40441
40442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40443   void * jresult ;
40444   Dali::PanGestureDetector::Property *result = 0 ;
40445
40446   {
40447     try {
40448       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40449     } catch (std::out_of_range& e) {
40450       {
40451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40452       };
40453     } catch (std::exception& e) {
40454       {
40455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40456       };
40457     } catch (Dali::DaliException e) {
40458       {
40459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40460       };
40461     } catch (...) {
40462       {
40463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40464       };
40465     }
40466   }
40467
40468   jresult = (void *)result;
40469   return jresult;
40470 }
40471
40472
40473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40474   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40475
40476   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40477   {
40478     try {
40479       delete arg1;
40480     } catch (std::out_of_range& e) {
40481       {
40482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40483       };
40484     } catch (std::exception& e) {
40485       {
40486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40487       };
40488     } catch (Dali::DaliException e) {
40489       {
40490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40491       };
40492     } catch (...) {
40493       {
40494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40495       };
40496     }
40497   }
40498
40499 }
40500
40501
40502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40503   void * jresult ;
40504   Dali::Radian *result = 0 ;
40505
40506   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40507   jresult = (void *)result;
40508   return jresult;
40509 }
40510
40511
40512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40513   void * jresult ;
40514   Dali::Radian *result = 0 ;
40515
40516   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40517   jresult = (void *)result;
40518   return jresult;
40519 }
40520
40521
40522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40523   void * jresult ;
40524   Dali::Radian *result = 0 ;
40525
40526   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40527   jresult = (void *)result;
40528   return jresult;
40529 }
40530
40531
40532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40533   void * jresult ;
40534   Dali::Radian *result = 0 ;
40535
40536   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40537   jresult = (void *)result;
40538   return jresult;
40539 }
40540
40541
40542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40543   void * jresult ;
40544   Dali::Radian *result = 0 ;
40545
40546   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40547   jresult = (void *)result;
40548   return jresult;
40549 }
40550
40551
40552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40553   void * jresult ;
40554   Dali::Radian *result = 0 ;
40555
40556   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40557   jresult = (void *)result;
40558   return jresult;
40559 }
40560
40561
40562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40563   void * jresult ;
40564   Dali::Radian *result = 0 ;
40565
40566   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40567   jresult = (void *)result;
40568   return jresult;
40569 }
40570
40571
40572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40573   void * jresult ;
40574   Dali::PanGestureDetector *result = 0 ;
40575
40576   {
40577     try {
40578       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40579     } catch (std::out_of_range& e) {
40580       {
40581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40582       };
40583     } catch (std::exception& e) {
40584       {
40585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40586       };
40587     } catch (Dali::DaliException e) {
40588       {
40589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40590       };
40591     } catch (...) {
40592       {
40593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40594       };
40595     }
40596   }
40597
40598   jresult = (void *)result;
40599   return jresult;
40600 }
40601
40602
40603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40604   void * jresult ;
40605   Dali::PanGestureDetector result;
40606
40607   {
40608     try {
40609       result = Dali::PanGestureDetector::New();
40610     } catch (std::out_of_range& e) {
40611       {
40612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40613       };
40614     } catch (std::exception& e) {
40615       {
40616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40617       };
40618     } catch (Dali::DaliException e) {
40619       {
40620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40621       };
40622     } catch (...) {
40623       {
40624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40625       };
40626     }
40627   }
40628
40629   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40630   return jresult;
40631 }
40632
40633
40634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40635   void * jresult ;
40636   Dali::BaseHandle arg1 ;
40637   Dali::BaseHandle *argp1 ;
40638   Dali::PanGestureDetector result;
40639
40640   argp1 = (Dali::BaseHandle *)jarg1;
40641   if (!argp1) {
40642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40643     return 0;
40644   }
40645   arg1 = *argp1;
40646   {
40647     try {
40648       result = Dali::PanGestureDetector::DownCast(arg1);
40649     } catch (std::out_of_range& e) {
40650       {
40651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40652       };
40653     } catch (std::exception& e) {
40654       {
40655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40656       };
40657     } catch (Dali::DaliException e) {
40658       {
40659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40660       };
40661     } catch (...) {
40662       {
40663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40664       };
40665     }
40666   }
40667
40668   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40669   return jresult;
40670 }
40671
40672
40673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40674   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40675
40676   arg1 = (Dali::PanGestureDetector *)jarg1;
40677   {
40678     try {
40679       delete arg1;
40680     } catch (std::out_of_range& e) {
40681       {
40682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40683       };
40684     } catch (std::exception& e) {
40685       {
40686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40687       };
40688     } catch (Dali::DaliException e) {
40689       {
40690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40691       };
40692     } catch (...) {
40693       {
40694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40695       };
40696     }
40697   }
40698
40699 }
40700
40701
40702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40703   void * jresult ;
40704   Dali::PanGestureDetector *arg1 = 0 ;
40705   Dali::PanGestureDetector *result = 0 ;
40706
40707   arg1 = (Dali::PanGestureDetector *)jarg1;
40708   if (!arg1) {
40709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40710     return 0;
40711   }
40712   {
40713     try {
40714       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40715     } catch (std::out_of_range& e) {
40716       {
40717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40718       };
40719     } catch (std::exception& e) {
40720       {
40721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40722       };
40723     } catch (Dali::DaliException e) {
40724       {
40725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40726       };
40727     } catch (...) {
40728       {
40729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40730       };
40731     }
40732   }
40733
40734   jresult = (void *)result;
40735   return jresult;
40736 }
40737
40738
40739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40740   void * jresult ;
40741   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40742   Dali::PanGestureDetector *arg2 = 0 ;
40743   Dali::PanGestureDetector *result = 0 ;
40744
40745   arg1 = (Dali::PanGestureDetector *)jarg1;
40746   arg2 = (Dali::PanGestureDetector *)jarg2;
40747   if (!arg2) {
40748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40749     return 0;
40750   }
40751   {
40752     try {
40753       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40754     } catch (std::out_of_range& e) {
40755       {
40756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40757       };
40758     } catch (std::exception& e) {
40759       {
40760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40761       };
40762     } catch (Dali::DaliException e) {
40763       {
40764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40765       };
40766     } catch (...) {
40767       {
40768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40769       };
40770     }
40771   }
40772
40773   jresult = (void *)result;
40774   return jresult;
40775 }
40776
40777
40778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40779   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40780   unsigned int arg2 ;
40781
40782   arg1 = (Dali::PanGestureDetector *)jarg1;
40783   arg2 = (unsigned int)jarg2;
40784   {
40785     try {
40786       (arg1)->SetMinimumTouchesRequired(arg2);
40787     } catch (std::out_of_range& e) {
40788       {
40789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40790       };
40791     } catch (std::exception& e) {
40792       {
40793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40794       };
40795     } catch (Dali::DaliException e) {
40796       {
40797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40798       };
40799     } catch (...) {
40800       {
40801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40802       };
40803     }
40804   }
40805
40806 }
40807
40808
40809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40810   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40811   unsigned int arg2 ;
40812
40813   arg1 = (Dali::PanGestureDetector *)jarg1;
40814   arg2 = (unsigned int)jarg2;
40815   {
40816     try {
40817       (arg1)->SetMaximumTouchesRequired(arg2);
40818     } catch (std::out_of_range& e) {
40819       {
40820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40821       };
40822     } catch (std::exception& e) {
40823       {
40824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40825       };
40826     } catch (Dali::DaliException e) {
40827       {
40828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40829       };
40830     } catch (...) {
40831       {
40832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40833       };
40834     }
40835   }
40836
40837 }
40838
40839
40840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40841   unsigned int jresult ;
40842   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40843   unsigned int result;
40844
40845   arg1 = (Dali::PanGestureDetector *)jarg1;
40846   {
40847     try {
40848       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40849     } catch (std::out_of_range& e) {
40850       {
40851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40852       };
40853     } catch (std::exception& e) {
40854       {
40855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40856       };
40857     } catch (Dali::DaliException e) {
40858       {
40859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40860       };
40861     } catch (...) {
40862       {
40863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40864       };
40865     }
40866   }
40867
40868   jresult = result;
40869   return jresult;
40870 }
40871
40872
40873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40874   unsigned int jresult ;
40875   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40876   unsigned int result;
40877
40878   arg1 = (Dali::PanGestureDetector *)jarg1;
40879   {
40880     try {
40881       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40882     } catch (std::out_of_range& e) {
40883       {
40884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40885       };
40886     } catch (std::exception& e) {
40887       {
40888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40889       };
40890     } catch (Dali::DaliException e) {
40891       {
40892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40893       };
40894     } catch (...) {
40895       {
40896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40897       };
40898     }
40899   }
40900
40901   jresult = result;
40902   return jresult;
40903 }
40904
40905
40906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40907   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40908   Dali::Radian arg2 ;
40909   Dali::Radian arg3 ;
40910   Dali::Radian *argp2 ;
40911   Dali::Radian *argp3 ;
40912
40913   arg1 = (Dali::PanGestureDetector *)jarg1;
40914   argp2 = (Dali::Radian *)jarg2;
40915   if (!argp2) {
40916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40917     return ;
40918   }
40919   arg2 = *argp2;
40920   argp3 = (Dali::Radian *)jarg3;
40921   if (!argp3) {
40922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40923     return ;
40924   }
40925   arg3 = *argp3;
40926   {
40927     try {
40928       (arg1)->AddAngle(arg2,arg3);
40929     } catch (std::out_of_range& e) {
40930       {
40931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40932       };
40933     } catch (std::exception& e) {
40934       {
40935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40936       };
40937     } catch (Dali::DaliException e) {
40938       {
40939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40940       };
40941     } catch (...) {
40942       {
40943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40944       };
40945     }
40946   }
40947
40948 }
40949
40950
40951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40952   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40953   Dali::Radian arg2 ;
40954   Dali::Radian *argp2 ;
40955
40956   arg1 = (Dali::PanGestureDetector *)jarg1;
40957   argp2 = (Dali::Radian *)jarg2;
40958   if (!argp2) {
40959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40960     return ;
40961   }
40962   arg2 = *argp2;
40963   {
40964     try {
40965       (arg1)->AddAngle(arg2);
40966     } catch (std::out_of_range& e) {
40967       {
40968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40969       };
40970     } catch (std::exception& e) {
40971       {
40972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40973       };
40974     } catch (Dali::DaliException e) {
40975       {
40976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40977       };
40978     } catch (...) {
40979       {
40980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40981       };
40982     }
40983   }
40984
40985 }
40986
40987
40988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40989   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40990   Dali::Radian arg2 ;
40991   Dali::Radian arg3 ;
40992   Dali::Radian *argp2 ;
40993   Dali::Radian *argp3 ;
40994
40995   arg1 = (Dali::PanGestureDetector *)jarg1;
40996   argp2 = (Dali::Radian *)jarg2;
40997   if (!argp2) {
40998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40999     return ;
41000   }
41001   arg2 = *argp2;
41002   argp3 = (Dali::Radian *)jarg3;
41003   if (!argp3) {
41004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41005     return ;
41006   }
41007   arg3 = *argp3;
41008   {
41009     try {
41010       (arg1)->AddDirection(arg2,arg3);
41011     } catch (std::out_of_range& e) {
41012       {
41013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41014       };
41015     } catch (std::exception& e) {
41016       {
41017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41018       };
41019     } catch (Dali::DaliException e) {
41020       {
41021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41022       };
41023     } catch (...) {
41024       {
41025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41026       };
41027     }
41028   }
41029
41030 }
41031
41032
41033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41034   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41035   Dali::Radian arg2 ;
41036   Dali::Radian *argp2 ;
41037
41038   arg1 = (Dali::PanGestureDetector *)jarg1;
41039   argp2 = (Dali::Radian *)jarg2;
41040   if (!argp2) {
41041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41042     return ;
41043   }
41044   arg2 = *argp2;
41045   {
41046     try {
41047       (arg1)->AddDirection(arg2);
41048     } catch (std::out_of_range& e) {
41049       {
41050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41051       };
41052     } catch (std::exception& e) {
41053       {
41054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41055       };
41056     } catch (Dali::DaliException e) {
41057       {
41058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41059       };
41060     } catch (...) {
41061       {
41062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41063       };
41064     }
41065   }
41066
41067 }
41068
41069
41070 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41071   unsigned long jresult ;
41072   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41073   size_t result;
41074
41075   arg1 = (Dali::PanGestureDetector *)jarg1;
41076   {
41077     try {
41078       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41079     } catch (std::out_of_range& e) {
41080       {
41081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41082       };
41083     } catch (std::exception& e) {
41084       {
41085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41086       };
41087     } catch (Dali::DaliException e) {
41088       {
41089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41090       };
41091     } catch (...) {
41092       {
41093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41094       };
41095     }
41096   }
41097
41098   jresult = (unsigned long)result;
41099   return jresult;
41100 }
41101
41102
41103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41104   void * jresult ;
41105   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41106   size_t arg2 ;
41107   Dali::PanGestureDetector::AngleThresholdPair result;
41108
41109   arg1 = (Dali::PanGestureDetector *)jarg1;
41110   arg2 = (size_t)jarg2;
41111   {
41112     try {
41113       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41114     } catch (std::out_of_range& e) {
41115       {
41116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41117       };
41118     } catch (std::exception& e) {
41119       {
41120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41121       };
41122     } catch (Dali::DaliException e) {
41123       {
41124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41125       };
41126     } catch (...) {
41127       {
41128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41129       };
41130     }
41131   }
41132
41133   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41134   return jresult;
41135 }
41136
41137
41138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41139   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41140
41141   arg1 = (Dali::PanGestureDetector *)jarg1;
41142   {
41143     try {
41144       (arg1)->ClearAngles();
41145     } catch (std::out_of_range& e) {
41146       {
41147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41148       };
41149     } catch (std::exception& e) {
41150       {
41151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41152       };
41153     } catch (Dali::DaliException e) {
41154       {
41155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41156       };
41157     } catch (...) {
41158       {
41159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41160       };
41161     }
41162   }
41163
41164 }
41165
41166
41167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41168   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41169   Dali::Radian arg2 ;
41170   Dali::Radian *argp2 ;
41171
41172   arg1 = (Dali::PanGestureDetector *)jarg1;
41173   argp2 = (Dali::Radian *)jarg2;
41174   if (!argp2) {
41175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41176     return ;
41177   }
41178   arg2 = *argp2;
41179   {
41180     try {
41181       (arg1)->RemoveAngle(arg2);
41182     } catch (std::out_of_range& e) {
41183       {
41184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41185       };
41186     } catch (std::exception& e) {
41187       {
41188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41189       };
41190     } catch (Dali::DaliException e) {
41191       {
41192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41193       };
41194     } catch (...) {
41195       {
41196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41197       };
41198     }
41199   }
41200
41201 }
41202
41203
41204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41205   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41206   Dali::Radian arg2 ;
41207   Dali::Radian *argp2 ;
41208
41209   arg1 = (Dali::PanGestureDetector *)jarg1;
41210   argp2 = (Dali::Radian *)jarg2;
41211   if (!argp2) {
41212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41213     return ;
41214   }
41215   arg2 = *argp2;
41216   {
41217     try {
41218       (arg1)->RemoveDirection(arg2);
41219     } catch (std::out_of_range& e) {
41220       {
41221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41222       };
41223     } catch (std::exception& e) {
41224       {
41225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41226       };
41227     } catch (Dali::DaliException e) {
41228       {
41229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41230       };
41231     } catch (...) {
41232       {
41233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41234       };
41235     }
41236   }
41237
41238 }
41239
41240
41241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41242   void * jresult ;
41243   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41244   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41245
41246   arg1 = (Dali::PanGestureDetector *)jarg1;
41247   {
41248     try {
41249       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41250     } catch (std::out_of_range& e) {
41251       {
41252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41253       };
41254     } catch (std::exception& e) {
41255       {
41256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41257       };
41258     } catch (Dali::DaliException e) {
41259       {
41260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41261       };
41262     } catch (...) {
41263       {
41264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41265       };
41266     }
41267   }
41268
41269   jresult = (void *)result;
41270   return jresult;
41271 }
41272
41273
41274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41275   Dali::PanGesture *arg1 = 0 ;
41276
41277   arg1 = (Dali::PanGesture *)jarg1;
41278   if (!arg1) {
41279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41280     return ;
41281   }
41282   {
41283     try {
41284       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41285     } catch (std::out_of_range& e) {
41286       {
41287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41288       };
41289     } catch (std::exception& e) {
41290       {
41291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41292       };
41293     } catch (Dali::DaliException e) {
41294       {
41295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41296       };
41297     } catch (...) {
41298       {
41299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41300       };
41301     }
41302   }
41303
41304 }
41305
41306
41307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41308   void * jresult ;
41309   Dali::PanGesture *result = 0 ;
41310
41311   {
41312     try {
41313       result = (Dali::PanGesture *)new Dali::PanGesture();
41314     } catch (std::out_of_range& e) {
41315       {
41316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41317       };
41318     } catch (std::exception& e) {
41319       {
41320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41321       };
41322     } catch (Dali::DaliException e) {
41323       {
41324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41325       };
41326     } catch (...) {
41327       {
41328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41329       };
41330     }
41331   }
41332
41333   jresult = (void *)result;
41334   return jresult;
41335 }
41336
41337
41338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41339   void * jresult ;
41340   Dali::Gesture::State arg1 ;
41341   Dali::PanGesture *result = 0 ;
41342
41343   arg1 = (Dali::Gesture::State)jarg1;
41344   {
41345     try {
41346       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41347     } catch (std::out_of_range& e) {
41348       {
41349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41350       };
41351     } catch (std::exception& e) {
41352       {
41353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41354       };
41355     } catch (Dali::DaliException e) {
41356       {
41357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41358       };
41359     } catch (...) {
41360       {
41361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41362       };
41363     }
41364   }
41365
41366   jresult = (void *)result;
41367   return jresult;
41368 }
41369
41370
41371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41372   void * jresult ;
41373   Dali::PanGesture *arg1 = 0 ;
41374   Dali::PanGesture *result = 0 ;
41375
41376   arg1 = (Dali::PanGesture *)jarg1;
41377   if (!arg1) {
41378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41379     return 0;
41380   }
41381   {
41382     try {
41383       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41384     } catch (std::out_of_range& e) {
41385       {
41386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41387       };
41388     } catch (std::exception& e) {
41389       {
41390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41391       };
41392     } catch (Dali::DaliException e) {
41393       {
41394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41395       };
41396     } catch (...) {
41397       {
41398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41399       };
41400     }
41401   }
41402
41403   jresult = (void *)result;
41404   return jresult;
41405 }
41406
41407
41408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41409   void * jresult ;
41410   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41411   Dali::PanGesture *arg2 = 0 ;
41412   Dali::PanGesture *result = 0 ;
41413
41414   arg1 = (Dali::PanGesture *)jarg1;
41415   arg2 = (Dali::PanGesture *)jarg2;
41416   if (!arg2) {
41417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41418     return 0;
41419   }
41420   {
41421     try {
41422       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41423     } catch (std::out_of_range& e) {
41424       {
41425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41426       };
41427     } catch (std::exception& e) {
41428       {
41429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41430       };
41431     } catch (Dali::DaliException e) {
41432       {
41433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41434       };
41435     } catch (...) {
41436       {
41437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41438       };
41439     }
41440   }
41441
41442   jresult = (void *)result;
41443   return jresult;
41444 }
41445
41446
41447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41448   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41449
41450   arg1 = (Dali::PanGesture *)jarg1;
41451   {
41452     try {
41453       delete arg1;
41454     } catch (std::out_of_range& e) {
41455       {
41456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41457       };
41458     } catch (std::exception& e) {
41459       {
41460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41461       };
41462     } catch (Dali::DaliException e) {
41463       {
41464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41465       };
41466     } catch (...) {
41467       {
41468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41469       };
41470     }
41471   }
41472
41473 }
41474
41475
41476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41477   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41478   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41479
41480   arg1 = (Dali::PanGesture *)jarg1;
41481   arg2 = (Dali::Vector2 *)jarg2;
41482   if (arg1) (arg1)->velocity = *arg2;
41483 }
41484
41485
41486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41487   void * jresult ;
41488   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41489   Dali::Vector2 *result = 0 ;
41490
41491   arg1 = (Dali::PanGesture *)jarg1;
41492   result = (Dali::Vector2 *)& ((arg1)->velocity);
41493   jresult = (void *)result;
41494   return jresult;
41495 }
41496
41497
41498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41499   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41500   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41501
41502   arg1 = (Dali::PanGesture *)jarg1;
41503   arg2 = (Dali::Vector2 *)jarg2;
41504   if (arg1) (arg1)->displacement = *arg2;
41505 }
41506
41507
41508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41509   void * jresult ;
41510   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41511   Dali::Vector2 *result = 0 ;
41512
41513   arg1 = (Dali::PanGesture *)jarg1;
41514   result = (Dali::Vector2 *)& ((arg1)->displacement);
41515   jresult = (void *)result;
41516   return jresult;
41517 }
41518
41519
41520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41521   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41522   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41523
41524   arg1 = (Dali::PanGesture *)jarg1;
41525   arg2 = (Dali::Vector2 *)jarg2;
41526   if (arg1) (arg1)->position = *arg2;
41527 }
41528
41529
41530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41531   void * jresult ;
41532   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41533   Dali::Vector2 *result = 0 ;
41534
41535   arg1 = (Dali::PanGesture *)jarg1;
41536   result = (Dali::Vector2 *)& ((arg1)->position);
41537   jresult = (void *)result;
41538   return jresult;
41539 }
41540
41541
41542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41543   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41544   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41545
41546   arg1 = (Dali::PanGesture *)jarg1;
41547   arg2 = (Dali::Vector2 *)jarg2;
41548   if (arg1) (arg1)->screenVelocity = *arg2;
41549 }
41550
41551
41552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41553   void * jresult ;
41554   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41555   Dali::Vector2 *result = 0 ;
41556
41557   arg1 = (Dali::PanGesture *)jarg1;
41558   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41559   jresult = (void *)result;
41560   return jresult;
41561 }
41562
41563
41564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41565   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41566   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41567
41568   arg1 = (Dali::PanGesture *)jarg1;
41569   arg2 = (Dali::Vector2 *)jarg2;
41570   if (arg1) (arg1)->screenDisplacement = *arg2;
41571 }
41572
41573
41574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41575   void * jresult ;
41576   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41577   Dali::Vector2 *result = 0 ;
41578
41579   arg1 = (Dali::PanGesture *)jarg1;
41580   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41581   jresult = (void *)result;
41582   return jresult;
41583 }
41584
41585
41586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41587   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41588   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41589
41590   arg1 = (Dali::PanGesture *)jarg1;
41591   arg2 = (Dali::Vector2 *)jarg2;
41592   if (arg1) (arg1)->screenPosition = *arg2;
41593 }
41594
41595
41596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41597   void * jresult ;
41598   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41599   Dali::Vector2 *result = 0 ;
41600
41601   arg1 = (Dali::PanGesture *)jarg1;
41602   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41603   jresult = (void *)result;
41604   return jresult;
41605 }
41606
41607
41608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41609   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41610   unsigned int arg2 ;
41611
41612   arg1 = (Dali::PanGesture *)jarg1;
41613   arg2 = (unsigned int)jarg2;
41614   if (arg1) (arg1)->numberOfTouches = arg2;
41615 }
41616
41617
41618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41619   unsigned int jresult ;
41620   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41621   unsigned int result;
41622
41623   arg1 = (Dali::PanGesture *)jarg1;
41624   result = (unsigned int) ((arg1)->numberOfTouches);
41625   jresult = result;
41626   return jresult;
41627 }
41628
41629
41630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41631   float jresult ;
41632   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41633   float result;
41634
41635   arg1 = (Dali::PanGesture *)jarg1;
41636   {
41637     try {
41638       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41639     } catch (std::out_of_range& e) {
41640       {
41641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41642       };
41643     } catch (std::exception& e) {
41644       {
41645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41646       };
41647     } catch (Dali::DaliException e) {
41648       {
41649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41650       };
41651     } catch (...) {
41652       {
41653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41654       };
41655     }
41656   }
41657
41658   jresult = result;
41659   return jresult;
41660 }
41661
41662
41663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41664   float jresult ;
41665   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41666   float result;
41667
41668   arg1 = (Dali::PanGesture *)jarg1;
41669   {
41670     try {
41671       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41672     } catch (std::out_of_range& e) {
41673       {
41674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41675       };
41676     } catch (std::exception& e) {
41677       {
41678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41679       };
41680     } catch (Dali::DaliException e) {
41681       {
41682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41683       };
41684     } catch (...) {
41685       {
41686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41687       };
41688     }
41689   }
41690
41691   jresult = result;
41692   return jresult;
41693 }
41694
41695
41696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41697   float jresult ;
41698   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41699   float result;
41700
41701   arg1 = (Dali::PanGesture *)jarg1;
41702   {
41703     try {
41704       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41705     } catch (std::out_of_range& e) {
41706       {
41707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41708       };
41709     } catch (std::exception& e) {
41710       {
41711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41712       };
41713     } catch (Dali::DaliException e) {
41714       {
41715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41716       };
41717     } catch (...) {
41718       {
41719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41720       };
41721     }
41722   }
41723
41724   jresult = result;
41725   return jresult;
41726 }
41727
41728
41729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41730   float jresult ;
41731   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41732   float result;
41733
41734   arg1 = (Dali::PanGesture *)jarg1;
41735   {
41736     try {
41737       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41738     } catch (std::out_of_range& e) {
41739       {
41740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41741       };
41742     } catch (std::exception& e) {
41743       {
41744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41745       };
41746     } catch (Dali::DaliException e) {
41747       {
41748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41749       };
41750     } catch (...) {
41751       {
41752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41753       };
41754     }
41755   }
41756
41757   jresult = result;
41758   return jresult;
41759 }
41760
41761
41762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41763   void * jresult ;
41764   Dali::PinchGestureDetector *result = 0 ;
41765
41766   {
41767     try {
41768       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41769     } catch (std::out_of_range& e) {
41770       {
41771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41772       };
41773     } catch (std::exception& e) {
41774       {
41775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41776       };
41777     } catch (Dali::DaliException e) {
41778       {
41779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41780       };
41781     } catch (...) {
41782       {
41783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41784       };
41785     }
41786   }
41787
41788   jresult = (void *)result;
41789   return jresult;
41790 }
41791
41792
41793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41794   void * jresult ;
41795   Dali::PinchGestureDetector result;
41796
41797   {
41798     try {
41799       result = Dali::PinchGestureDetector::New();
41800     } catch (std::out_of_range& e) {
41801       {
41802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41803       };
41804     } catch (std::exception& e) {
41805       {
41806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41807       };
41808     } catch (Dali::DaliException e) {
41809       {
41810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41811       };
41812     } catch (...) {
41813       {
41814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41815       };
41816     }
41817   }
41818
41819   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41820   return jresult;
41821 }
41822
41823
41824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41825   void * jresult ;
41826   Dali::BaseHandle arg1 ;
41827   Dali::BaseHandle *argp1 ;
41828   Dali::PinchGestureDetector result;
41829
41830   argp1 = (Dali::BaseHandle *)jarg1;
41831   if (!argp1) {
41832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41833     return 0;
41834   }
41835   arg1 = *argp1;
41836   {
41837     try {
41838       result = Dali::PinchGestureDetector::DownCast(arg1);
41839     } catch (std::out_of_range& e) {
41840       {
41841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41842       };
41843     } catch (std::exception& e) {
41844       {
41845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41846       };
41847     } catch (Dali::DaliException e) {
41848       {
41849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41850       };
41851     } catch (...) {
41852       {
41853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41854       };
41855     }
41856   }
41857
41858   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41859   return jresult;
41860 }
41861
41862
41863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41864   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41865
41866   arg1 = (Dali::PinchGestureDetector *)jarg1;
41867   {
41868     try {
41869       delete arg1;
41870     } catch (std::out_of_range& e) {
41871       {
41872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41873       };
41874     } catch (std::exception& e) {
41875       {
41876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41877       };
41878     } catch (Dali::DaliException e) {
41879       {
41880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41881       };
41882     } catch (...) {
41883       {
41884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41885       };
41886     }
41887   }
41888
41889 }
41890
41891
41892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41893   void * jresult ;
41894   Dali::PinchGestureDetector *arg1 = 0 ;
41895   Dali::PinchGestureDetector *result = 0 ;
41896
41897   arg1 = (Dali::PinchGestureDetector *)jarg1;
41898   if (!arg1) {
41899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41900     return 0;
41901   }
41902   {
41903     try {
41904       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41905     } catch (std::out_of_range& e) {
41906       {
41907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41908       };
41909     } catch (std::exception& e) {
41910       {
41911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41912       };
41913     } catch (Dali::DaliException e) {
41914       {
41915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41916       };
41917     } catch (...) {
41918       {
41919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41920       };
41921     }
41922   }
41923
41924   jresult = (void *)result;
41925   return jresult;
41926 }
41927
41928
41929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41930   void * jresult ;
41931   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41932   Dali::PinchGestureDetector *arg2 = 0 ;
41933   Dali::PinchGestureDetector *result = 0 ;
41934
41935   arg1 = (Dali::PinchGestureDetector *)jarg1;
41936   arg2 = (Dali::PinchGestureDetector *)jarg2;
41937   if (!arg2) {
41938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41939     return 0;
41940   }
41941   {
41942     try {
41943       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41944     } catch (std::out_of_range& e) {
41945       {
41946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41947       };
41948     } catch (std::exception& e) {
41949       {
41950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41951       };
41952     } catch (Dali::DaliException e) {
41953       {
41954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41955       };
41956     } catch (...) {
41957       {
41958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41959       };
41960     }
41961   }
41962
41963   jresult = (void *)result;
41964   return jresult;
41965 }
41966
41967
41968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41969   void * jresult ;
41970   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41971   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41972
41973   arg1 = (Dali::PinchGestureDetector *)jarg1;
41974   {
41975     try {
41976       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41977     } catch (std::out_of_range& e) {
41978       {
41979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41980       };
41981     } catch (std::exception& e) {
41982       {
41983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41984       };
41985     } catch (Dali::DaliException e) {
41986       {
41987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41988       };
41989     } catch (...) {
41990       {
41991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41992       };
41993     }
41994   }
41995
41996   jresult = (void *)result;
41997   return jresult;
41998 }
41999
42000
42001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42002   void * jresult ;
42003   Dali::Gesture::State arg1 ;
42004   Dali::PinchGesture *result = 0 ;
42005
42006   arg1 = (Dali::Gesture::State)jarg1;
42007   {
42008     try {
42009       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42010     } catch (std::out_of_range& e) {
42011       {
42012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42013       };
42014     } catch (std::exception& e) {
42015       {
42016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42017       };
42018     } catch (Dali::DaliException e) {
42019       {
42020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42021       };
42022     } catch (...) {
42023       {
42024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42025       };
42026     }
42027   }
42028
42029   jresult = (void *)result;
42030   return jresult;
42031 }
42032
42033
42034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42035   void * jresult ;
42036   Dali::PinchGesture *arg1 = 0 ;
42037   Dali::PinchGesture *result = 0 ;
42038
42039   arg1 = (Dali::PinchGesture *)jarg1;
42040   if (!arg1) {
42041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42042     return 0;
42043   }
42044   {
42045     try {
42046       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42047     } catch (std::out_of_range& e) {
42048       {
42049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42050       };
42051     } catch (std::exception& e) {
42052       {
42053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42054       };
42055     } catch (Dali::DaliException e) {
42056       {
42057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42058       };
42059     } catch (...) {
42060       {
42061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42062       };
42063     }
42064   }
42065
42066   jresult = (void *)result;
42067   return jresult;
42068 }
42069
42070
42071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42072   void * jresult ;
42073   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42074   Dali::PinchGesture *arg2 = 0 ;
42075   Dali::PinchGesture *result = 0 ;
42076
42077   arg1 = (Dali::PinchGesture *)jarg1;
42078   arg2 = (Dali::PinchGesture *)jarg2;
42079   if (!arg2) {
42080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42081     return 0;
42082   }
42083   {
42084     try {
42085       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42086     } catch (std::out_of_range& e) {
42087       {
42088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42089       };
42090     } catch (std::exception& e) {
42091       {
42092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42093       };
42094     } catch (Dali::DaliException e) {
42095       {
42096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42097       };
42098     } catch (...) {
42099       {
42100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42101       };
42102     }
42103   }
42104
42105   jresult = (void *)result;
42106   return jresult;
42107 }
42108
42109
42110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42111   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42112
42113   arg1 = (Dali::PinchGesture *)jarg1;
42114   {
42115     try {
42116       delete arg1;
42117     } catch (std::out_of_range& e) {
42118       {
42119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42120       };
42121     } catch (std::exception& e) {
42122       {
42123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42124       };
42125     } catch (Dali::DaliException e) {
42126       {
42127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42128       };
42129     } catch (...) {
42130       {
42131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42132       };
42133     }
42134   }
42135
42136 }
42137
42138
42139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42140   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42141   float arg2 ;
42142
42143   arg1 = (Dali::PinchGesture *)jarg1;
42144   arg2 = (float)jarg2;
42145   if (arg1) (arg1)->scale = arg2;
42146 }
42147
42148
42149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42150   float jresult ;
42151   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42152   float result;
42153
42154   arg1 = (Dali::PinchGesture *)jarg1;
42155   result = (float) ((arg1)->scale);
42156   jresult = result;
42157   return jresult;
42158 }
42159
42160
42161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42162   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42163   float arg2 ;
42164
42165   arg1 = (Dali::PinchGesture *)jarg1;
42166   arg2 = (float)jarg2;
42167   if (arg1) (arg1)->speed = arg2;
42168 }
42169
42170
42171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42172   float jresult ;
42173   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42174   float result;
42175
42176   arg1 = (Dali::PinchGesture *)jarg1;
42177   result = (float) ((arg1)->speed);
42178   jresult = result;
42179   return jresult;
42180 }
42181
42182
42183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42184   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42185   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42186
42187   arg1 = (Dali::PinchGesture *)jarg1;
42188   arg2 = (Dali::Vector2 *)jarg2;
42189   if (arg1) (arg1)->screenCenterPoint = *arg2;
42190 }
42191
42192
42193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42194   void * jresult ;
42195   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42196   Dali::Vector2 *result = 0 ;
42197
42198   arg1 = (Dali::PinchGesture *)jarg1;
42199   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42200   jresult = (void *)result;
42201   return jresult;
42202 }
42203
42204
42205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42206   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42207   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42208
42209   arg1 = (Dali::PinchGesture *)jarg1;
42210   arg2 = (Dali::Vector2 *)jarg2;
42211   if (arg1) (arg1)->localCenterPoint = *arg2;
42212 }
42213
42214
42215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42216   void * jresult ;
42217   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42218   Dali::Vector2 *result = 0 ;
42219
42220   arg1 = (Dali::PinchGesture *)jarg1;
42221   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42222   jresult = (void *)result;
42223   return jresult;
42224 }
42225
42226
42227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42228   void * jresult ;
42229   Dali::TapGestureDetector *result = 0 ;
42230
42231   {
42232     try {
42233       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42234     } catch (std::out_of_range& e) {
42235       {
42236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42237       };
42238     } catch (std::exception& e) {
42239       {
42240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42241       };
42242     } catch (Dali::DaliException e) {
42243       {
42244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42245       };
42246     } catch (...) {
42247       {
42248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42249       };
42250     }
42251   }
42252
42253   jresult = (void *)result;
42254   return jresult;
42255 }
42256
42257
42258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42259   void * jresult ;
42260   Dali::TapGestureDetector result;
42261
42262   {
42263     try {
42264       result = Dali::TapGestureDetector::New();
42265     } catch (std::out_of_range& e) {
42266       {
42267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42268       };
42269     } catch (std::exception& e) {
42270       {
42271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42272       };
42273     } catch (Dali::DaliException e) {
42274       {
42275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42276       };
42277     } catch (...) {
42278       {
42279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42280       };
42281     }
42282   }
42283
42284   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42285   return jresult;
42286 }
42287
42288
42289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42290   void * jresult ;
42291   unsigned int arg1 ;
42292   Dali::TapGestureDetector result;
42293
42294   arg1 = (unsigned int)jarg1;
42295   {
42296     try {
42297       result = Dali::TapGestureDetector::New(arg1);
42298     } catch (std::out_of_range& e) {
42299       {
42300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42301       };
42302     } catch (std::exception& e) {
42303       {
42304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42305       };
42306     } catch (Dali::DaliException e) {
42307       {
42308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42309       };
42310     } catch (...) {
42311       {
42312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42313       };
42314     }
42315   }
42316
42317   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42318   return jresult;
42319 }
42320
42321
42322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42323   void * jresult ;
42324   Dali::BaseHandle arg1 ;
42325   Dali::BaseHandle *argp1 ;
42326   Dali::TapGestureDetector result;
42327
42328   argp1 = (Dali::BaseHandle *)jarg1;
42329   if (!argp1) {
42330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42331     return 0;
42332   }
42333   arg1 = *argp1;
42334   {
42335     try {
42336       result = Dali::TapGestureDetector::DownCast(arg1);
42337     } catch (std::out_of_range& e) {
42338       {
42339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42340       };
42341     } catch (std::exception& e) {
42342       {
42343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42344       };
42345     } catch (Dali::DaliException e) {
42346       {
42347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42348       };
42349     } catch (...) {
42350       {
42351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42352       };
42353     }
42354   }
42355
42356   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42357   return jresult;
42358 }
42359
42360
42361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42362   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42363
42364   arg1 = (Dali::TapGestureDetector *)jarg1;
42365   {
42366     try {
42367       delete arg1;
42368     } catch (std::out_of_range& e) {
42369       {
42370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42371       };
42372     } catch (std::exception& e) {
42373       {
42374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42375       };
42376     } catch (Dali::DaliException e) {
42377       {
42378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42379       };
42380     } catch (...) {
42381       {
42382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42383       };
42384     }
42385   }
42386
42387 }
42388
42389
42390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42391   void * jresult ;
42392   Dali::TapGestureDetector *arg1 = 0 ;
42393   Dali::TapGestureDetector *result = 0 ;
42394
42395   arg1 = (Dali::TapGestureDetector *)jarg1;
42396   if (!arg1) {
42397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42398     return 0;
42399   }
42400   {
42401     try {
42402       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42403     } catch (std::out_of_range& e) {
42404       {
42405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42406       };
42407     } catch (std::exception& e) {
42408       {
42409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42410       };
42411     } catch (Dali::DaliException e) {
42412       {
42413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42414       };
42415     } catch (...) {
42416       {
42417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42418       };
42419     }
42420   }
42421
42422   jresult = (void *)result;
42423   return jresult;
42424 }
42425
42426
42427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42428   void * jresult ;
42429   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42430   Dali::TapGestureDetector *arg2 = 0 ;
42431   Dali::TapGestureDetector *result = 0 ;
42432
42433   arg1 = (Dali::TapGestureDetector *)jarg1;
42434   arg2 = (Dali::TapGestureDetector *)jarg2;
42435   if (!arg2) {
42436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42437     return 0;
42438   }
42439   {
42440     try {
42441       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42442     } catch (std::out_of_range& e) {
42443       {
42444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42445       };
42446     } catch (std::exception& e) {
42447       {
42448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42449       };
42450     } catch (Dali::DaliException e) {
42451       {
42452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42453       };
42454     } catch (...) {
42455       {
42456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42457       };
42458     }
42459   }
42460
42461   jresult = (void *)result;
42462   return jresult;
42463 }
42464
42465
42466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42467   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42468   unsigned int arg2 ;
42469
42470   arg1 = (Dali::TapGestureDetector *)jarg1;
42471   arg2 = (unsigned int)jarg2;
42472   {
42473     try {
42474       (arg1)->SetMinimumTapsRequired(arg2);
42475     } catch (std::out_of_range& e) {
42476       {
42477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42478       };
42479     } catch (std::exception& e) {
42480       {
42481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42482       };
42483     } catch (Dali::DaliException e) {
42484       {
42485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42486       };
42487     } catch (...) {
42488       {
42489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42490       };
42491     }
42492   }
42493
42494 }
42495
42496
42497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42498   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42499   unsigned int arg2 ;
42500
42501   arg1 = (Dali::TapGestureDetector *)jarg1;
42502   arg2 = (unsigned int)jarg2;
42503   {
42504     try {
42505       (arg1)->SetMaximumTapsRequired(arg2);
42506     } catch (std::out_of_range& e) {
42507       {
42508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42509       };
42510     } catch (std::exception& e) {
42511       {
42512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42513       };
42514     } catch (Dali::DaliException e) {
42515       {
42516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42517       };
42518     } catch (...) {
42519       {
42520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42521       };
42522     }
42523   }
42524
42525 }
42526
42527
42528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42529   unsigned int jresult ;
42530   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42531   unsigned int result;
42532
42533   arg1 = (Dali::TapGestureDetector *)jarg1;
42534   {
42535     try {
42536       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42537     } catch (std::out_of_range& e) {
42538       {
42539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42540       };
42541     } catch (std::exception& e) {
42542       {
42543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42544       };
42545     } catch (Dali::DaliException e) {
42546       {
42547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42548       };
42549     } catch (...) {
42550       {
42551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42552       };
42553     }
42554   }
42555
42556   jresult = result;
42557   return jresult;
42558 }
42559
42560
42561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42562   unsigned int jresult ;
42563   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42564   unsigned int result;
42565
42566   arg1 = (Dali::TapGestureDetector *)jarg1;
42567   {
42568     try {
42569       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42570     } catch (std::out_of_range& e) {
42571       {
42572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42573       };
42574     } catch (std::exception& e) {
42575       {
42576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42577       };
42578     } catch (Dali::DaliException e) {
42579       {
42580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42581       };
42582     } catch (...) {
42583       {
42584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42585       };
42586     }
42587   }
42588
42589   jresult = result;
42590   return jresult;
42591 }
42592
42593
42594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42595   void * jresult ;
42596   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42597   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42598
42599   arg1 = (Dali::TapGestureDetector *)jarg1;
42600   {
42601     try {
42602       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42603     } catch (std::out_of_range& e) {
42604       {
42605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42606       };
42607     } catch (std::exception& e) {
42608       {
42609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42610       };
42611     } catch (Dali::DaliException e) {
42612       {
42613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42614       };
42615     } catch (...) {
42616       {
42617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42618       };
42619     }
42620   }
42621
42622   jresult = (void *)result;
42623   return jresult;
42624 }
42625
42626
42627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42628   void * jresult ;
42629   Dali::TapGesture *result = 0 ;
42630
42631   {
42632     try {
42633       result = (Dali::TapGesture *)new Dali::TapGesture();
42634     } catch (std::out_of_range& e) {
42635       {
42636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42637       };
42638     } catch (std::exception& e) {
42639       {
42640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42641       };
42642     } catch (Dali::DaliException e) {
42643       {
42644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42645       };
42646     } catch (...) {
42647       {
42648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42649       };
42650     }
42651   }
42652
42653   jresult = (void *)result;
42654   return jresult;
42655 }
42656
42657
42658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42659   void * jresult ;
42660   Dali::TapGesture *arg1 = 0 ;
42661   Dali::TapGesture *result = 0 ;
42662
42663   arg1 = (Dali::TapGesture *)jarg1;
42664   if (!arg1) {
42665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42666     return 0;
42667   }
42668   {
42669     try {
42670       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42671     } catch (std::out_of_range& e) {
42672       {
42673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42674       };
42675     } catch (std::exception& e) {
42676       {
42677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42678       };
42679     } catch (Dali::DaliException e) {
42680       {
42681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42682       };
42683     } catch (...) {
42684       {
42685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42686       };
42687     }
42688   }
42689
42690   jresult = (void *)result;
42691   return jresult;
42692 }
42693
42694
42695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42696   void * jresult ;
42697   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42698   Dali::TapGesture *arg2 = 0 ;
42699   Dali::TapGesture *result = 0 ;
42700
42701   arg1 = (Dali::TapGesture *)jarg1;
42702   arg2 = (Dali::TapGesture *)jarg2;
42703   if (!arg2) {
42704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42705     return 0;
42706   }
42707   {
42708     try {
42709       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42710     } catch (std::out_of_range& e) {
42711       {
42712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42713       };
42714     } catch (std::exception& e) {
42715       {
42716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42717       };
42718     } catch (Dali::DaliException e) {
42719       {
42720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42721       };
42722     } catch (...) {
42723       {
42724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42725       };
42726     }
42727   }
42728
42729   jresult = (void *)result;
42730   return jresult;
42731 }
42732
42733
42734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42735   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42736
42737   arg1 = (Dali::TapGesture *)jarg1;
42738   {
42739     try {
42740       delete arg1;
42741     } catch (std::out_of_range& e) {
42742       {
42743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42744       };
42745     } catch (std::exception& e) {
42746       {
42747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42748       };
42749     } catch (Dali::DaliException e) {
42750       {
42751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42752       };
42753     } catch (...) {
42754       {
42755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42756       };
42757     }
42758   }
42759
42760 }
42761
42762
42763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42764   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42765   unsigned int arg2 ;
42766
42767   arg1 = (Dali::TapGesture *)jarg1;
42768   arg2 = (unsigned int)jarg2;
42769   if (arg1) (arg1)->numberOfTaps = arg2;
42770 }
42771
42772
42773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42774   unsigned int jresult ;
42775   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42776   unsigned int result;
42777
42778   arg1 = (Dali::TapGesture *)jarg1;
42779   result = (unsigned int) ((arg1)->numberOfTaps);
42780   jresult = result;
42781   return jresult;
42782 }
42783
42784
42785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42786   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42787   unsigned int arg2 ;
42788
42789   arg1 = (Dali::TapGesture *)jarg1;
42790   arg2 = (unsigned int)jarg2;
42791   if (arg1) (arg1)->numberOfTouches = arg2;
42792 }
42793
42794
42795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42796   unsigned int jresult ;
42797   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42798   unsigned int result;
42799
42800   arg1 = (Dali::TapGesture *)jarg1;
42801   result = (unsigned int) ((arg1)->numberOfTouches);
42802   jresult = result;
42803   return jresult;
42804 }
42805
42806
42807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42808   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42809   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42810
42811   arg1 = (Dali::TapGesture *)jarg1;
42812   arg2 = (Dali::Vector2 *)jarg2;
42813   if (arg1) (arg1)->screenPoint = *arg2;
42814 }
42815
42816
42817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42818   void * jresult ;
42819   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42820   Dali::Vector2 *result = 0 ;
42821
42822   arg1 = (Dali::TapGesture *)jarg1;
42823   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42824   jresult = (void *)result;
42825   return jresult;
42826 }
42827
42828
42829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42830   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42831   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42832
42833   arg1 = (Dali::TapGesture *)jarg1;
42834   arg2 = (Dali::Vector2 *)jarg2;
42835   if (arg1) (arg1)->localPoint = *arg2;
42836 }
42837
42838
42839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42840   void * jresult ;
42841   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42842   Dali::Vector2 *result = 0 ;
42843
42844   arg1 = (Dali::TapGesture *)jarg1;
42845   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42846   jresult = (void *)result;
42847   return jresult;
42848 }
42849
42850
42851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42852   void * jresult ;
42853   Dali::AlphaFunction *result = 0 ;
42854
42855   {
42856     try {
42857       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42858     } catch (std::out_of_range& e) {
42859       {
42860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42861       };
42862     } catch (std::exception& e) {
42863       {
42864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42865       };
42866     } catch (Dali::DaliException e) {
42867       {
42868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42869       };
42870     } catch (...) {
42871       {
42872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42873       };
42874     }
42875   }
42876
42877   jresult = (void *)result;
42878   return jresult;
42879 }
42880
42881
42882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42883   void * jresult ;
42884   Dali::AlphaFunction::BuiltinFunction arg1 ;
42885   Dali::AlphaFunction *result = 0 ;
42886
42887   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42888   {
42889     try {
42890       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42891     } catch (std::out_of_range& e) {
42892       {
42893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42894       };
42895     } catch (std::exception& e) {
42896       {
42897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42898       };
42899     } catch (Dali::DaliException e) {
42900       {
42901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42902       };
42903     } catch (...) {
42904       {
42905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42906       };
42907     }
42908   }
42909
42910   jresult = (void *)result;
42911   return jresult;
42912 }
42913
42914
42915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42916   void * jresult ;
42917   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42918   Dali::AlphaFunction *result = 0 ;
42919
42920   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42921   {
42922     try {
42923       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42924     } catch (std::out_of_range& e) {
42925       {
42926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42927       };
42928     } catch (std::exception& e) {
42929       {
42930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42931       };
42932     } catch (Dali::DaliException e) {
42933       {
42934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42935       };
42936     } catch (...) {
42937       {
42938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42939       };
42940     }
42941   }
42942
42943   jresult = (void *)result;
42944   return jresult;
42945 }
42946
42947
42948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42949   void * jresult ;
42950   Dali::Vector2 *arg1 = 0 ;
42951   Dali::Vector2 *arg2 = 0 ;
42952   Dali::AlphaFunction *result = 0 ;
42953
42954   arg1 = (Dali::Vector2 *)jarg1;
42955   if (!arg1) {
42956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42957     return 0;
42958   }
42959   arg2 = (Dali::Vector2 *)jarg2;
42960   if (!arg2) {
42961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42962     return 0;
42963   }
42964   {
42965     try {
42966       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42967     } catch (std::out_of_range& e) {
42968       {
42969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42970       };
42971     } catch (std::exception& e) {
42972       {
42973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42974       };
42975     } catch (Dali::DaliException e) {
42976       {
42977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42978       };
42979     } catch (...) {
42980       {
42981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42982       };
42983     }
42984   }
42985
42986   jresult = (void *)result;
42987   return jresult;
42988 }
42989
42990
42991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42992   void * jresult ;
42993   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42994   Dali::Vector4 result;
42995
42996   arg1 = (Dali::AlphaFunction *)jarg1;
42997   {
42998     try {
42999       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43000     } catch (std::out_of_range& e) {
43001       {
43002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43003       };
43004     } catch (std::exception& e) {
43005       {
43006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43007       };
43008     } catch (Dali::DaliException e) {
43009       {
43010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43011       };
43012     } catch (...) {
43013       {
43014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43015       };
43016     }
43017   }
43018
43019   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43020   return jresult;
43021 }
43022
43023
43024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43025   void * jresult ;
43026   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43027   Dali::AlphaFunctionPrototype result;
43028
43029   arg1 = (Dali::AlphaFunction *)jarg1;
43030   {
43031     try {
43032       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43033     } catch (std::out_of_range& e) {
43034       {
43035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43036       };
43037     } catch (std::exception& e) {
43038       {
43039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43040       };
43041     } catch (Dali::DaliException e) {
43042       {
43043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43044       };
43045     } catch (...) {
43046       {
43047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43048       };
43049     }
43050   }
43051
43052   jresult = (void *)result;
43053   return jresult;
43054 }
43055
43056
43057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43058   int jresult ;
43059   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43060   Dali::AlphaFunction::BuiltinFunction result;
43061
43062   arg1 = (Dali::AlphaFunction *)jarg1;
43063   {
43064     try {
43065       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43066     } catch (std::out_of_range& e) {
43067       {
43068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43069       };
43070     } catch (std::exception& e) {
43071       {
43072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43073       };
43074     } catch (Dali::DaliException e) {
43075       {
43076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43077       };
43078     } catch (...) {
43079       {
43080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43081       };
43082     }
43083   }
43084
43085   jresult = (int)result;
43086   return jresult;
43087 }
43088
43089
43090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43091   int jresult ;
43092   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43093   Dali::AlphaFunction::Mode result;
43094
43095   arg1 = (Dali::AlphaFunction *)jarg1;
43096   {
43097     try {
43098       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43099     } catch (std::out_of_range& e) {
43100       {
43101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43102       };
43103     } catch (std::exception& e) {
43104       {
43105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43106       };
43107     } catch (Dali::DaliException e) {
43108       {
43109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43110       };
43111     } catch (...) {
43112       {
43113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43114       };
43115     }
43116   }
43117
43118   jresult = (int)result;
43119   return jresult;
43120 }
43121
43122
43123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43124   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43125
43126   arg1 = (Dali::AlphaFunction *)jarg1;
43127   {
43128     try {
43129       delete arg1;
43130     } catch (std::out_of_range& e) {
43131       {
43132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43133       };
43134     } catch (std::exception& e) {
43135       {
43136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43137       };
43138     } catch (Dali::DaliException e) {
43139       {
43140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43141       };
43142     } catch (...) {
43143       {
43144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43145       };
43146     }
43147   }
43148
43149 }
43150
43151
43152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43153   void * jresult ;
43154   Dali::KeyFrames result;
43155
43156   {
43157     try {
43158       result = Dali::KeyFrames::New();
43159     } catch (std::out_of_range& e) {
43160       {
43161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43162       };
43163     } catch (std::exception& e) {
43164       {
43165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43166       };
43167     } catch (Dali::DaliException e) {
43168       {
43169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43170       };
43171     } catch (...) {
43172       {
43173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43174       };
43175     }
43176   }
43177
43178   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43179   return jresult;
43180 }
43181
43182
43183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43184   void * jresult ;
43185   Dali::BaseHandle arg1 ;
43186   Dali::BaseHandle *argp1 ;
43187   Dali::KeyFrames result;
43188
43189   argp1 = (Dali::BaseHandle *)jarg1;
43190   if (!argp1) {
43191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43192     return 0;
43193   }
43194   arg1 = *argp1;
43195   {
43196     try {
43197       result = Dali::KeyFrames::DownCast(arg1);
43198     } catch (std::out_of_range& e) {
43199       {
43200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43201       };
43202     } catch (std::exception& e) {
43203       {
43204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43205       };
43206     } catch (Dali::DaliException e) {
43207       {
43208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43209       };
43210     } catch (...) {
43211       {
43212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43213       };
43214     }
43215   }
43216
43217   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43218   return jresult;
43219 }
43220
43221
43222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43223   void * jresult ;
43224   Dali::KeyFrames *result = 0 ;
43225
43226   {
43227     try {
43228       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43229     } catch (std::out_of_range& e) {
43230       {
43231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43232       };
43233     } catch (std::exception& e) {
43234       {
43235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43236       };
43237     } catch (Dali::DaliException e) {
43238       {
43239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43240       };
43241     } catch (...) {
43242       {
43243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43244       };
43245     }
43246   }
43247
43248   jresult = (void *)result;
43249   return jresult;
43250 }
43251
43252
43253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43254   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43255
43256   arg1 = (Dali::KeyFrames *)jarg1;
43257   {
43258     try {
43259       delete arg1;
43260     } catch (std::out_of_range& e) {
43261       {
43262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43263       };
43264     } catch (std::exception& e) {
43265       {
43266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43267       };
43268     } catch (Dali::DaliException e) {
43269       {
43270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43271       };
43272     } catch (...) {
43273       {
43274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43275       };
43276     }
43277   }
43278
43279 }
43280
43281
43282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43283   void * jresult ;
43284   Dali::KeyFrames *arg1 = 0 ;
43285   Dali::KeyFrames *result = 0 ;
43286
43287   arg1 = (Dali::KeyFrames *)jarg1;
43288   if (!arg1) {
43289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43290     return 0;
43291   }
43292   {
43293     try {
43294       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43295     } catch (std::out_of_range& e) {
43296       {
43297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43298       };
43299     } catch (std::exception& e) {
43300       {
43301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43302       };
43303     } catch (Dali::DaliException e) {
43304       {
43305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43306       };
43307     } catch (...) {
43308       {
43309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43310       };
43311     }
43312   }
43313
43314   jresult = (void *)result;
43315   return jresult;
43316 }
43317
43318
43319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43320   void * jresult ;
43321   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43322   Dali::KeyFrames *arg2 = 0 ;
43323   Dali::KeyFrames *result = 0 ;
43324
43325   arg1 = (Dali::KeyFrames *)jarg1;
43326   arg2 = (Dali::KeyFrames *)jarg2;
43327   if (!arg2) {
43328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43329     return 0;
43330   }
43331   {
43332     try {
43333       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43334     } catch (std::out_of_range& e) {
43335       {
43336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43337       };
43338     } catch (std::exception& e) {
43339       {
43340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43341       };
43342     } catch (Dali::DaliException e) {
43343       {
43344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43345       };
43346     } catch (...) {
43347       {
43348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43349       };
43350     }
43351   }
43352
43353   jresult = (void *)result;
43354   return jresult;
43355 }
43356
43357
43358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43359   int jresult ;
43360   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43361   Dali::Property::Type result;
43362
43363   arg1 = (Dali::KeyFrames *)jarg1;
43364   {
43365     try {
43366       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43367     } catch (std::out_of_range& e) {
43368       {
43369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43370       };
43371     } catch (std::exception& e) {
43372       {
43373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43374       };
43375     } catch (Dali::DaliException e) {
43376       {
43377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43378       };
43379     } catch (...) {
43380       {
43381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43382       };
43383     }
43384   }
43385
43386   jresult = (int)result;
43387   return jresult;
43388 }
43389
43390
43391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43392   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43393   float arg2 ;
43394   Dali::Property::Value arg3 ;
43395   Dali::Property::Value *argp3 ;
43396
43397   arg1 = (Dali::KeyFrames *)jarg1;
43398   arg2 = (float)jarg2;
43399   argp3 = (Dali::Property::Value *)jarg3;
43400   if (!argp3) {
43401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43402     return ;
43403   }
43404   arg3 = *argp3;
43405   {
43406     try {
43407       (arg1)->Add(arg2,arg3);
43408     } catch (std::out_of_range& e) {
43409       {
43410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43411       };
43412     } catch (std::exception& e) {
43413       {
43414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43415       };
43416     } catch (Dali::DaliException e) {
43417       {
43418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43419       };
43420     } catch (...) {
43421       {
43422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43423       };
43424     }
43425   }
43426
43427 }
43428
43429
43430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43431   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43432   float arg2 ;
43433   Dali::Property::Value arg3 ;
43434   Dali::AlphaFunction arg4 ;
43435   Dali::Property::Value *argp3 ;
43436   Dali::AlphaFunction *argp4 ;
43437
43438   arg1 = (Dali::KeyFrames *)jarg1;
43439   arg2 = (float)jarg2;
43440   argp3 = (Dali::Property::Value *)jarg3;
43441   if (!argp3) {
43442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43443     return ;
43444   }
43445   arg3 = *argp3;
43446   argp4 = (Dali::AlphaFunction *)jarg4;
43447   if (!argp4) {
43448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43449     return ;
43450   }
43451   arg4 = *argp4;
43452   {
43453     try {
43454       (arg1)->Add(arg2,arg3,arg4);
43455     } catch (std::out_of_range& e) {
43456       {
43457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43458       };
43459     } catch (std::exception& e) {
43460       {
43461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43462       };
43463     } catch (Dali::DaliException e) {
43464       {
43465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43466       };
43467     } catch (...) {
43468       {
43469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43470       };
43471     }
43472   }
43473
43474 }
43475
43476
43477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43478   int jresult ;
43479   int result;
43480
43481   result = (int)Dali::Path::Property::POINTS;
43482   jresult = (int)result;
43483   return jresult;
43484 }
43485
43486
43487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43488   int jresult ;
43489   int result;
43490
43491   result = (int)Dali::Path::Property::CONTROL_POINTS;
43492   jresult = (int)result;
43493   return jresult;
43494 }
43495
43496
43497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43498   void * jresult ;
43499   Dali::Path::Property *result = 0 ;
43500
43501   {
43502     try {
43503       result = (Dali::Path::Property *)new Dali::Path::Property();
43504     } catch (std::out_of_range& e) {
43505       {
43506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43507       };
43508     } catch (std::exception& e) {
43509       {
43510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43511       };
43512     } catch (Dali::DaliException e) {
43513       {
43514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43515       };
43516     } catch (...) {
43517       {
43518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43519       };
43520     }
43521   }
43522
43523   jresult = (void *)result;
43524   return jresult;
43525 }
43526
43527
43528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43529   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43530
43531   arg1 = (Dali::Path::Property *)jarg1;
43532   {
43533     try {
43534       delete arg1;
43535     } catch (std::out_of_range& e) {
43536       {
43537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43538       };
43539     } catch (std::exception& e) {
43540       {
43541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43542       };
43543     } catch (Dali::DaliException e) {
43544       {
43545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43546       };
43547     } catch (...) {
43548       {
43549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43550       };
43551     }
43552   }
43553
43554 }
43555
43556
43557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43558   void * jresult ;
43559   Dali::Path result;
43560
43561   {
43562     try {
43563       result = Dali::Path::New();
43564     } catch (std::out_of_range& e) {
43565       {
43566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43567       };
43568     } catch (std::exception& e) {
43569       {
43570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43571       };
43572     } catch (Dali::DaliException e) {
43573       {
43574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43575       };
43576     } catch (...) {
43577       {
43578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43579       };
43580     }
43581   }
43582
43583   jresult = new Dali::Path((const Dali::Path &)result);
43584   return jresult;
43585 }
43586
43587
43588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43589   void * jresult ;
43590   Dali::BaseHandle arg1 ;
43591   Dali::BaseHandle *argp1 ;
43592   Dali::Path result;
43593
43594   argp1 = (Dali::BaseHandle *)jarg1;
43595   if (!argp1) {
43596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43597     return 0;
43598   }
43599   arg1 = *argp1;
43600   {
43601     try {
43602       result = Dali::Path::DownCast(arg1);
43603     } catch (std::out_of_range& e) {
43604       {
43605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43606       };
43607     } catch (std::exception& e) {
43608       {
43609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43610       };
43611     } catch (Dali::DaliException e) {
43612       {
43613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43614       };
43615     } catch (...) {
43616       {
43617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43618       };
43619     }
43620   }
43621
43622   jresult = new Dali::Path((const Dali::Path &)result);
43623   return jresult;
43624 }
43625
43626
43627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43628   void * jresult ;
43629   Dali::Path *result = 0 ;
43630
43631   {
43632     try {
43633       result = (Dali::Path *)new Dali::Path();
43634     } catch (std::out_of_range& e) {
43635       {
43636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43637       };
43638     } catch (std::exception& e) {
43639       {
43640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43641       };
43642     } catch (Dali::DaliException e) {
43643       {
43644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43645       };
43646     } catch (...) {
43647       {
43648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43649       };
43650     }
43651   }
43652
43653   jresult = (void *)result;
43654   return jresult;
43655 }
43656
43657
43658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43659   Dali::Path *arg1 = (Dali::Path *) 0 ;
43660
43661   arg1 = (Dali::Path *)jarg1;
43662   {
43663     try {
43664       delete arg1;
43665     } catch (std::out_of_range& e) {
43666       {
43667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43668       };
43669     } catch (std::exception& e) {
43670       {
43671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43672       };
43673     } catch (Dali::DaliException e) {
43674       {
43675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43676       };
43677     } catch (...) {
43678       {
43679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43680       };
43681     }
43682   }
43683
43684 }
43685
43686
43687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43688   void * jresult ;
43689   Dali::Path *arg1 = 0 ;
43690   Dali::Path *result = 0 ;
43691
43692   arg1 = (Dali::Path *)jarg1;
43693   if (!arg1) {
43694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43695     return 0;
43696   }
43697   {
43698     try {
43699       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43700     } catch (std::out_of_range& e) {
43701       {
43702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43703       };
43704     } catch (std::exception& e) {
43705       {
43706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43707       };
43708     } catch (Dali::DaliException e) {
43709       {
43710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43711       };
43712     } catch (...) {
43713       {
43714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43715       };
43716     }
43717   }
43718
43719   jresult = (void *)result;
43720   return jresult;
43721 }
43722
43723
43724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43725   void * jresult ;
43726   Dali::Path *arg1 = (Dali::Path *) 0 ;
43727   Dali::Path *arg2 = 0 ;
43728   Dali::Path *result = 0 ;
43729
43730   arg1 = (Dali::Path *)jarg1;
43731   arg2 = (Dali::Path *)jarg2;
43732   if (!arg2) {
43733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43734     return 0;
43735   }
43736   {
43737     try {
43738       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43739     } catch (std::out_of_range& e) {
43740       {
43741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43742       };
43743     } catch (std::exception& e) {
43744       {
43745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43746       };
43747     } catch (Dali::DaliException e) {
43748       {
43749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43750       };
43751     } catch (...) {
43752       {
43753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43754       };
43755     }
43756   }
43757
43758   jresult = (void *)result;
43759   return jresult;
43760 }
43761
43762
43763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43764   Dali::Path *arg1 = (Dali::Path *) 0 ;
43765   Dali::Vector3 *arg2 = 0 ;
43766
43767   arg1 = (Dali::Path *)jarg1;
43768   arg2 = (Dali::Vector3 *)jarg2;
43769   if (!arg2) {
43770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43771     return ;
43772   }
43773   {
43774     try {
43775       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43776     } catch (std::out_of_range& e) {
43777       {
43778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43779       };
43780     } catch (std::exception& e) {
43781       {
43782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43783       };
43784     } catch (Dali::DaliException e) {
43785       {
43786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43787       };
43788     } catch (...) {
43789       {
43790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43791       };
43792     }
43793   }
43794
43795 }
43796
43797
43798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43799   Dali::Path *arg1 = (Dali::Path *) 0 ;
43800   Dali::Vector3 *arg2 = 0 ;
43801
43802   arg1 = (Dali::Path *)jarg1;
43803   arg2 = (Dali::Vector3 *)jarg2;
43804   if (!arg2) {
43805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43806     return ;
43807   }
43808   {
43809     try {
43810       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43811     } catch (std::out_of_range& e) {
43812       {
43813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43814       };
43815     } catch (std::exception& e) {
43816       {
43817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43818       };
43819     } catch (Dali::DaliException e) {
43820       {
43821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43822       };
43823     } catch (...) {
43824       {
43825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43826       };
43827     }
43828   }
43829
43830 }
43831
43832
43833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43834   Dali::Path *arg1 = (Dali::Path *) 0 ;
43835   float arg2 ;
43836
43837   arg1 = (Dali::Path *)jarg1;
43838   arg2 = (float)jarg2;
43839   {
43840     try {
43841       (arg1)->GenerateControlPoints(arg2);
43842     } catch (std::out_of_range& e) {
43843       {
43844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43845       };
43846     } catch (std::exception& e) {
43847       {
43848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43849       };
43850     } catch (Dali::DaliException e) {
43851       {
43852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43853       };
43854     } catch (...) {
43855       {
43856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43857       };
43858     }
43859   }
43860
43861 }
43862
43863
43864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43865   Dali::Path *arg1 = (Dali::Path *) 0 ;
43866   float arg2 ;
43867   Dali::Vector3 *arg3 = 0 ;
43868   Dali::Vector3 *arg4 = 0 ;
43869
43870   arg1 = (Dali::Path *)jarg1;
43871   arg2 = (float)jarg2;
43872   arg3 = (Dali::Vector3 *)jarg3;
43873   if (!arg3) {
43874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43875     return ;
43876   }
43877   arg4 = (Dali::Vector3 *)jarg4;
43878   if (!arg4) {
43879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43880     return ;
43881   }
43882   {
43883     try {
43884       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43885     } catch (std::out_of_range& e) {
43886       {
43887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43888       };
43889     } catch (std::exception& e) {
43890       {
43891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43892       };
43893     } catch (Dali::DaliException e) {
43894       {
43895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43896       };
43897     } catch (...) {
43898       {
43899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43900       };
43901     }
43902   }
43903
43904 }
43905
43906
43907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43908   void * jresult ;
43909   Dali::Path *arg1 = (Dali::Path *) 0 ;
43910   size_t arg2 ;
43911   Dali::Vector3 *result = 0 ;
43912
43913   arg1 = (Dali::Path *)jarg1;
43914   arg2 = (size_t)jarg2;
43915   {
43916     try {
43917       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43918     } catch (std::out_of_range& e) {
43919       {
43920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43921       };
43922     } catch (std::exception& e) {
43923       {
43924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43925       };
43926     } catch (Dali::DaliException e) {
43927       {
43928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43929       };
43930     } catch (...) {
43931       {
43932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43933       };
43934     }
43935   }
43936
43937   jresult = (void *)result;
43938   return jresult;
43939 }
43940
43941
43942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43943   void * jresult ;
43944   Dali::Path *arg1 = (Dali::Path *) 0 ;
43945   size_t arg2 ;
43946   Dali::Vector3 *result = 0 ;
43947
43948   arg1 = (Dali::Path *)jarg1;
43949   arg2 = (size_t)jarg2;
43950   {
43951     try {
43952       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43953     } catch (std::out_of_range& e) {
43954       {
43955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43956       };
43957     } catch (std::exception& e) {
43958       {
43959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43960       };
43961     } catch (Dali::DaliException e) {
43962       {
43963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43964       };
43965     } catch (...) {
43966       {
43967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43968       };
43969     }
43970   }
43971
43972   jresult = (void *)result;
43973   return jresult;
43974 }
43975
43976
43977 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43978   unsigned long jresult ;
43979   Dali::Path *arg1 = (Dali::Path *) 0 ;
43980   size_t result;
43981
43982   arg1 = (Dali::Path *)jarg1;
43983   {
43984     try {
43985       result = ((Dali::Path const *)arg1)->GetPointCount();
43986     } catch (std::out_of_range& e) {
43987       {
43988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43989       };
43990     } catch (std::exception& e) {
43991       {
43992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43993       };
43994     } catch (Dali::DaliException e) {
43995       {
43996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43997       };
43998     } catch (...) {
43999       {
44000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44001       };
44002     }
44003   }
44004
44005   jresult = (unsigned long)result;
44006   return jresult;
44007 }
44008
44009
44010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44011   void * jresult ;
44012   float arg1 ;
44013   Dali::TimePeriod *result = 0 ;
44014
44015   arg1 = (float)jarg1;
44016   {
44017     try {
44018       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44019     } catch (std::out_of_range& e) {
44020       {
44021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44022       };
44023     } catch (std::exception& e) {
44024       {
44025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44026       };
44027     } catch (Dali::DaliException e) {
44028       {
44029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44030       };
44031     } catch (...) {
44032       {
44033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44034       };
44035     }
44036   }
44037
44038   jresult = (void *)result;
44039   return jresult;
44040 }
44041
44042
44043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44044   void * jresult ;
44045   float arg1 ;
44046   float arg2 ;
44047   Dali::TimePeriod *result = 0 ;
44048
44049   arg1 = (float)jarg1;
44050   arg2 = (float)jarg2;
44051   {
44052     try {
44053       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44054     } catch (std::out_of_range& e) {
44055       {
44056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44057       };
44058     } catch (std::exception& e) {
44059       {
44060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44061       };
44062     } catch (Dali::DaliException e) {
44063       {
44064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44065       };
44066     } catch (...) {
44067       {
44068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44069       };
44070     }
44071   }
44072
44073   jresult = (void *)result;
44074   return jresult;
44075 }
44076
44077
44078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44079   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44080
44081   arg1 = (Dali::TimePeriod *)jarg1;
44082   {
44083     try {
44084       delete arg1;
44085     } catch (std::out_of_range& e) {
44086       {
44087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44088       };
44089     } catch (std::exception& e) {
44090       {
44091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44092       };
44093     } catch (Dali::DaliException e) {
44094       {
44095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44096       };
44097     } catch (...) {
44098       {
44099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44100       };
44101     }
44102   }
44103
44104 }
44105
44106
44107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44108   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44109   float arg2 ;
44110
44111   arg1 = (Dali::TimePeriod *)jarg1;
44112   arg2 = (float)jarg2;
44113   if (arg1) (arg1)->delaySeconds = arg2;
44114 }
44115
44116
44117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44118   float jresult ;
44119   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44120   float result;
44121
44122   arg1 = (Dali::TimePeriod *)jarg1;
44123   result = (float) ((arg1)->delaySeconds);
44124   jresult = result;
44125   return jresult;
44126 }
44127
44128
44129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44130   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44131   float arg2 ;
44132
44133   arg1 = (Dali::TimePeriod *)jarg1;
44134   arg2 = (float)jarg2;
44135   if (arg1) (arg1)->durationSeconds = arg2;
44136 }
44137
44138
44139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44140   float jresult ;
44141   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44142   float result;
44143
44144   arg1 = (Dali::TimePeriod *)jarg1;
44145   result = (float) ((arg1)->durationSeconds);
44146   jresult = result;
44147   return jresult;
44148 }
44149
44150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44151   int jresult ;
44152   int result;
44153
44154   result = (int)Dali::LinearConstrainer::Property::VALUE;
44155   jresult = (int)result;
44156   return jresult;
44157 }
44158
44159
44160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44161   int jresult ;
44162   int result;
44163
44164   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44165   jresult = (int)result;
44166   return jresult;
44167 }
44168
44169
44170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44171   void * jresult ;
44172   Dali::LinearConstrainer::Property *result = 0 ;
44173
44174   {
44175     try {
44176       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44177     } catch (std::out_of_range& e) {
44178       {
44179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44180       };
44181     } catch (std::exception& e) {
44182       {
44183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44184       };
44185     } catch (Dali::DaliException e) {
44186       {
44187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44188       };
44189     } catch (...) {
44190       {
44191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44192       };
44193     }
44194   }
44195
44196   jresult = (void *)result;
44197   return jresult;
44198 }
44199
44200
44201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44202   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44203
44204   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44205   {
44206     try {
44207       delete arg1;
44208     } catch (std::out_of_range& e) {
44209       {
44210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44211       };
44212     } catch (std::exception& e) {
44213       {
44214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44215       };
44216     } catch (Dali::DaliException e) {
44217       {
44218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44219       };
44220     } catch (...) {
44221       {
44222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44223       };
44224     }
44225   }
44226
44227 }
44228
44229
44230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44231   void * jresult ;
44232   Dali::LinearConstrainer result;
44233
44234   {
44235     try {
44236       result = Dali::LinearConstrainer::New();
44237     } catch (std::out_of_range& e) {
44238       {
44239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44240       };
44241     } catch (std::exception& e) {
44242       {
44243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44244       };
44245     } catch (Dali::DaliException e) {
44246       {
44247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44248       };
44249     } catch (...) {
44250       {
44251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44252       };
44253     }
44254   }
44255
44256   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44257   return jresult;
44258 }
44259
44260
44261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44262   void * jresult ;
44263   Dali::BaseHandle arg1 ;
44264   Dali::BaseHandle *argp1 ;
44265   Dali::LinearConstrainer result;
44266
44267   argp1 = (Dali::BaseHandle *)jarg1;
44268   if (!argp1) {
44269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44270     return 0;
44271   }
44272   arg1 = *argp1;
44273   {
44274     try {
44275       result = Dali::LinearConstrainer::DownCast(arg1);
44276     } catch (std::out_of_range& e) {
44277       {
44278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44279       };
44280     } catch (std::exception& e) {
44281       {
44282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44283       };
44284     } catch (Dali::DaliException e) {
44285       {
44286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44287       };
44288     } catch (...) {
44289       {
44290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44291       };
44292     }
44293   }
44294
44295   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44296   return jresult;
44297 }
44298
44299
44300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44301   void * jresult ;
44302   Dali::LinearConstrainer *result = 0 ;
44303
44304   {
44305     try {
44306       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44307     } catch (std::out_of_range& e) {
44308       {
44309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44310       };
44311     } catch (std::exception& e) {
44312       {
44313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44314       };
44315     } catch (Dali::DaliException e) {
44316       {
44317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44318       };
44319     } catch (...) {
44320       {
44321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44322       };
44323     }
44324   }
44325
44326   jresult = (void *)result;
44327   return jresult;
44328 }
44329
44330
44331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44332   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44333
44334   arg1 = (Dali::LinearConstrainer *)jarg1;
44335   {
44336     try {
44337       delete arg1;
44338     } catch (std::out_of_range& e) {
44339       {
44340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44341       };
44342     } catch (std::exception& e) {
44343       {
44344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44345       };
44346     } catch (Dali::DaliException e) {
44347       {
44348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44349       };
44350     } catch (...) {
44351       {
44352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44353       };
44354     }
44355   }
44356
44357 }
44358
44359
44360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44361   void * jresult ;
44362   Dali::LinearConstrainer *arg1 = 0 ;
44363   Dali::LinearConstrainer *result = 0 ;
44364
44365   arg1 = (Dali::LinearConstrainer *)jarg1;
44366   if (!arg1) {
44367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44368     return 0;
44369   }
44370   {
44371     try {
44372       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44373     } catch (std::out_of_range& e) {
44374       {
44375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44376       };
44377     } catch (std::exception& e) {
44378       {
44379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44380       };
44381     } catch (Dali::DaliException e) {
44382       {
44383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44384       };
44385     } catch (...) {
44386       {
44387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44388       };
44389     }
44390   }
44391
44392   jresult = (void *)result;
44393   return jresult;
44394 }
44395
44396
44397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44398   void * jresult ;
44399   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44400   Dali::LinearConstrainer *arg2 = 0 ;
44401   Dali::LinearConstrainer *result = 0 ;
44402
44403   arg1 = (Dali::LinearConstrainer *)jarg1;
44404   arg2 = (Dali::LinearConstrainer *)jarg2;
44405   if (!arg2) {
44406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44407     return 0;
44408   }
44409   {
44410     try {
44411       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44412     } catch (std::out_of_range& e) {
44413       {
44414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44415       };
44416     } catch (std::exception& e) {
44417       {
44418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44419       };
44420     } catch (Dali::DaliException e) {
44421       {
44422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44423       };
44424     } catch (...) {
44425       {
44426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44427       };
44428     }
44429   }
44430
44431   jresult = (void *)result;
44432   return jresult;
44433 }
44434
44435
44436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44437   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44438   SwigValueWrapper< Dali::Property > arg2 ;
44439   SwigValueWrapper< Dali::Property > arg3 ;
44440   Dali::Vector2 *arg4 = 0 ;
44441   Dali::Vector2 *arg5 = 0 ;
44442   Dali::Property *argp2 ;
44443   Dali::Property *argp3 ;
44444
44445   arg1 = (Dali::LinearConstrainer *)jarg1;
44446   argp2 = (Dali::Property *)jarg2;
44447   if (!argp2) {
44448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44449     return ;
44450   }
44451   arg2 = *argp2;
44452   argp3 = (Dali::Property *)jarg3;
44453   if (!argp3) {
44454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44455     return ;
44456   }
44457   arg3 = *argp3;
44458   arg4 = (Dali::Vector2 *)jarg4;
44459   if (!arg4) {
44460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44461     return ;
44462   }
44463   arg5 = (Dali::Vector2 *)jarg5;
44464   if (!arg5) {
44465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44466     return ;
44467   }
44468   {
44469     try {
44470       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44471     } catch (std::out_of_range& e) {
44472       {
44473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44474       };
44475     } catch (std::exception& e) {
44476       {
44477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44478       };
44479     } catch (Dali::DaliException e) {
44480       {
44481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44482       };
44483     } catch (...) {
44484       {
44485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44486       };
44487     }
44488   }
44489
44490 }
44491
44492
44493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44494   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44495   SwigValueWrapper< Dali::Property > arg2 ;
44496   SwigValueWrapper< Dali::Property > arg3 ;
44497   Dali::Vector2 *arg4 = 0 ;
44498   Dali::Property *argp2 ;
44499   Dali::Property *argp3 ;
44500
44501   arg1 = (Dali::LinearConstrainer *)jarg1;
44502   argp2 = (Dali::Property *)jarg2;
44503   if (!argp2) {
44504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44505     return ;
44506   }
44507   arg2 = *argp2;
44508   argp3 = (Dali::Property *)jarg3;
44509   if (!argp3) {
44510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44511     return ;
44512   }
44513   arg3 = *argp3;
44514   arg4 = (Dali::Vector2 *)jarg4;
44515   if (!arg4) {
44516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44517     return ;
44518   }
44519   {
44520     try {
44521       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44522     } catch (std::out_of_range& e) {
44523       {
44524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44525       };
44526     } catch (std::exception& e) {
44527       {
44528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44529       };
44530     } catch (Dali::DaliException e) {
44531       {
44532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44533       };
44534     } catch (...) {
44535       {
44536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44537       };
44538     }
44539   }
44540
44541 }
44542
44543
44544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44545   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44546   Dali::Handle *arg2 = 0 ;
44547
44548   arg1 = (Dali::LinearConstrainer *)jarg1;
44549   arg2 = (Dali::Handle *)jarg2;
44550   if (!arg2) {
44551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44552     return ;
44553   }
44554   {
44555     try {
44556       (arg1)->Remove(*arg2);
44557     } catch (std::out_of_range& e) {
44558       {
44559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44560       };
44561     } catch (std::exception& e) {
44562       {
44563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44564       };
44565     } catch (Dali::DaliException e) {
44566       {
44567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44568       };
44569     } catch (...) {
44570       {
44571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44572       };
44573     }
44574   }
44575
44576 }
44577
44578
44579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44580   int jresult ;
44581   int result;
44582
44583   result = (int)Dali::PathConstrainer::Property::FORWARD;
44584   jresult = (int)result;
44585   return jresult;
44586 }
44587
44588
44589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44590   int jresult ;
44591   int result;
44592
44593   result = (int)Dali::PathConstrainer::Property::POINTS;
44594   jresult = (int)result;
44595   return jresult;
44596 }
44597
44598
44599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44600   int jresult ;
44601   int result;
44602
44603   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44604   jresult = (int)result;
44605   return jresult;
44606 }
44607
44608
44609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44610   void * jresult ;
44611   Dali::PathConstrainer::Property *result = 0 ;
44612
44613   {
44614     try {
44615       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44616     } catch (std::out_of_range& e) {
44617       {
44618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44619       };
44620     } catch (std::exception& e) {
44621       {
44622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44623       };
44624     } catch (Dali::DaliException e) {
44625       {
44626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44627       };
44628     } catch (...) {
44629       {
44630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44631       };
44632     }
44633   }
44634
44635   jresult = (void *)result;
44636   return jresult;
44637 }
44638
44639
44640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44641   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44642
44643   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44644   {
44645     try {
44646       delete arg1;
44647     } catch (std::out_of_range& e) {
44648       {
44649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44650       };
44651     } catch (std::exception& e) {
44652       {
44653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44654       };
44655     } catch (Dali::DaliException e) {
44656       {
44657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44658       };
44659     } catch (...) {
44660       {
44661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44662       };
44663     }
44664   }
44665
44666 }
44667
44668
44669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44670   void * jresult ;
44671   Dali::PathConstrainer result;
44672
44673   {
44674     try {
44675       result = Dali::PathConstrainer::New();
44676     } catch (std::out_of_range& e) {
44677       {
44678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44679       };
44680     } catch (std::exception& e) {
44681       {
44682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44683       };
44684     } catch (Dali::DaliException e) {
44685       {
44686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44687       };
44688     } catch (...) {
44689       {
44690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44691       };
44692     }
44693   }
44694
44695   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44696   return jresult;
44697 }
44698
44699
44700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44701   void * jresult ;
44702   Dali::BaseHandle arg1 ;
44703   Dali::BaseHandle *argp1 ;
44704   Dali::PathConstrainer result;
44705
44706   argp1 = (Dali::BaseHandle *)jarg1;
44707   if (!argp1) {
44708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44709     return 0;
44710   }
44711   arg1 = *argp1;
44712   {
44713     try {
44714       result = Dali::PathConstrainer::DownCast(arg1);
44715     } catch (std::out_of_range& e) {
44716       {
44717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44718       };
44719     } catch (std::exception& e) {
44720       {
44721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44722       };
44723     } catch (Dali::DaliException e) {
44724       {
44725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44726       };
44727     } catch (...) {
44728       {
44729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44730       };
44731     }
44732   }
44733
44734   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44735   return jresult;
44736 }
44737
44738
44739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44740   void * jresult ;
44741   Dali::PathConstrainer *result = 0 ;
44742
44743   {
44744     try {
44745       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44746     } catch (std::out_of_range& e) {
44747       {
44748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44749       };
44750     } catch (std::exception& e) {
44751       {
44752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44753       };
44754     } catch (Dali::DaliException e) {
44755       {
44756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44757       };
44758     } catch (...) {
44759       {
44760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44761       };
44762     }
44763   }
44764
44765   jresult = (void *)result;
44766   return jresult;
44767 }
44768
44769
44770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44771   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44772
44773   arg1 = (Dali::PathConstrainer *)jarg1;
44774   {
44775     try {
44776       delete arg1;
44777     } catch (std::out_of_range& e) {
44778       {
44779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44780       };
44781     } catch (std::exception& e) {
44782       {
44783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44784       };
44785     } catch (Dali::DaliException e) {
44786       {
44787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44788       };
44789     } catch (...) {
44790       {
44791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44792       };
44793     }
44794   }
44795
44796 }
44797
44798
44799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44800   void * jresult ;
44801   Dali::PathConstrainer *arg1 = 0 ;
44802   Dali::PathConstrainer *result = 0 ;
44803
44804   arg1 = (Dali::PathConstrainer *)jarg1;
44805   if (!arg1) {
44806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44807     return 0;
44808   }
44809   {
44810     try {
44811       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44812     } catch (std::out_of_range& e) {
44813       {
44814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44815       };
44816     } catch (std::exception& e) {
44817       {
44818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44819       };
44820     } catch (Dali::DaliException e) {
44821       {
44822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44823       };
44824     } catch (...) {
44825       {
44826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44827       };
44828     }
44829   }
44830
44831   jresult = (void *)result;
44832   return jresult;
44833 }
44834
44835
44836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44837   void * jresult ;
44838   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44839   Dali::PathConstrainer *arg2 = 0 ;
44840   Dali::PathConstrainer *result = 0 ;
44841
44842   arg1 = (Dali::PathConstrainer *)jarg1;
44843   arg2 = (Dali::PathConstrainer *)jarg2;
44844   if (!arg2) {
44845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44846     return 0;
44847   }
44848   {
44849     try {
44850       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44851     } catch (std::out_of_range& e) {
44852       {
44853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44854       };
44855     } catch (std::exception& e) {
44856       {
44857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44858       };
44859     } catch (Dali::DaliException e) {
44860       {
44861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44862       };
44863     } catch (...) {
44864       {
44865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44866       };
44867     }
44868   }
44869
44870   jresult = (void *)result;
44871   return jresult;
44872 }
44873
44874
44875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44876   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44877   SwigValueWrapper< Dali::Property > arg2 ;
44878   SwigValueWrapper< Dali::Property > arg3 ;
44879   Dali::Vector2 *arg4 = 0 ;
44880   Dali::Vector2 *arg5 = 0 ;
44881   Dali::Property *argp2 ;
44882   Dali::Property *argp3 ;
44883
44884   arg1 = (Dali::PathConstrainer *)jarg1;
44885   argp2 = (Dali::Property *)jarg2;
44886   if (!argp2) {
44887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44888     return ;
44889   }
44890   arg2 = *argp2;
44891   argp3 = (Dali::Property *)jarg3;
44892   if (!argp3) {
44893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44894     return ;
44895   }
44896   arg3 = *argp3;
44897   arg4 = (Dali::Vector2 *)jarg4;
44898   if (!arg4) {
44899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44900     return ;
44901   }
44902   arg5 = (Dali::Vector2 *)jarg5;
44903   if (!arg5) {
44904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44905     return ;
44906   }
44907   {
44908     try {
44909       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44910     } catch (std::out_of_range& e) {
44911       {
44912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44913       };
44914     } catch (std::exception& e) {
44915       {
44916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44917       };
44918     } catch (Dali::DaliException e) {
44919       {
44920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44921       };
44922     } catch (...) {
44923       {
44924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44925       };
44926     }
44927   }
44928
44929 }
44930
44931
44932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44933   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44934   SwigValueWrapper< Dali::Property > arg2 ;
44935   SwigValueWrapper< Dali::Property > arg3 ;
44936   Dali::Vector2 *arg4 = 0 ;
44937   Dali::Property *argp2 ;
44938   Dali::Property *argp3 ;
44939
44940   arg1 = (Dali::PathConstrainer *)jarg1;
44941   argp2 = (Dali::Property *)jarg2;
44942   if (!argp2) {
44943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44944     return ;
44945   }
44946   arg2 = *argp2;
44947   argp3 = (Dali::Property *)jarg3;
44948   if (!argp3) {
44949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44950     return ;
44951   }
44952   arg3 = *argp3;
44953   arg4 = (Dali::Vector2 *)jarg4;
44954   if (!arg4) {
44955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44956     return ;
44957   }
44958   {
44959     try {
44960       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44961     } catch (std::out_of_range& e) {
44962       {
44963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44964       };
44965     } catch (std::exception& e) {
44966       {
44967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44968       };
44969     } catch (Dali::DaliException e) {
44970       {
44971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44972       };
44973     } catch (...) {
44974       {
44975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44976       };
44977     }
44978   }
44979
44980 }
44981
44982
44983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44984   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44985   Dali::Handle *arg2 = 0 ;
44986
44987   arg1 = (Dali::PathConstrainer *)jarg1;
44988   arg2 = (Dali::Handle *)jarg2;
44989   if (!arg2) {
44990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44991     return ;
44992   }
44993   {
44994     try {
44995       (arg1)->Remove(*arg2);
44996     } catch (std::out_of_range& e) {
44997       {
44998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44999       };
45000     } catch (std::exception& e) {
45001       {
45002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45003       };
45004     } catch (Dali::DaliException e) {
45005       {
45006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45007       };
45008     } catch (...) {
45009       {
45010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45011       };
45012     }
45013   }
45014
45015 }
45016
45017
45018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45019   int jresult ;
45020   Dali::FittingMode::Type result;
45021
45022   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45023   jresult = (int)result;
45024   return jresult;
45025 }
45026
45027
45028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45029   int jresult ;
45030   Dali::SamplingMode::Type result;
45031
45032   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45033   jresult = (int)result;
45034   return jresult;
45035 }
45036
45037
45038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45039   void * jresult ;
45040   Dali::BufferImage *result = 0 ;
45041
45042   {
45043     try {
45044       result = (Dali::BufferImage *)new Dali::BufferImage();
45045     } catch (std::out_of_range& e) {
45046       {
45047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45048       };
45049     } catch (std::exception& e) {
45050       {
45051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45052       };
45053     } catch (Dali::DaliException e) {
45054       {
45055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45056       };
45057     } catch (...) {
45058       {
45059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45060       };
45061     }
45062   }
45063
45064   jresult = (void *)result;
45065   return jresult;
45066 }
45067
45068
45069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45070   void * jresult ;
45071   unsigned int arg1 ;
45072   unsigned int arg2 ;
45073   Dali::Pixel::Format arg3 ;
45074   Dali::BufferImage result;
45075
45076   arg1 = (unsigned int)jarg1;
45077   arg2 = (unsigned int)jarg2;
45078   arg3 = (Dali::Pixel::Format)jarg3;
45079   {
45080     try {
45081       result = Dali::BufferImage::New(arg1,arg2,arg3);
45082     } catch (std::out_of_range& e) {
45083       {
45084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45085       };
45086     } catch (std::exception& e) {
45087       {
45088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45089       };
45090     } catch (Dali::DaliException e) {
45091       {
45092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45093       };
45094     } catch (...) {
45095       {
45096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45097       };
45098     }
45099   }
45100
45101   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45102   return jresult;
45103 }
45104
45105
45106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45107   void * jresult ;
45108   unsigned int arg1 ;
45109   unsigned int arg2 ;
45110   Dali::BufferImage result;
45111
45112   arg1 = (unsigned int)jarg1;
45113   arg2 = (unsigned int)jarg2;
45114   {
45115     try {
45116       result = Dali::BufferImage::New(arg1,arg2);
45117     } catch (std::out_of_range& e) {
45118       {
45119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45120       };
45121     } catch (std::exception& e) {
45122       {
45123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45124       };
45125     } catch (Dali::DaliException e) {
45126       {
45127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45128       };
45129     } catch (...) {
45130       {
45131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45132       };
45133     }
45134   }
45135
45136   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45137   return jresult;
45138 }
45139
45140
45141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45142   void * jresult ;
45143   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45144   unsigned int arg2 ;
45145   unsigned int arg3 ;
45146   Dali::Pixel::Format arg4 ;
45147   unsigned int arg5 ;
45148   Dali::BufferImage result;
45149
45150   arg1 = jarg1;
45151   arg2 = (unsigned int)jarg2;
45152   arg3 = (unsigned int)jarg3;
45153   arg4 = (Dali::Pixel::Format)jarg4;
45154   arg5 = (unsigned int)jarg5;
45155   {
45156     try {
45157       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45158     } catch (std::out_of_range& e) {
45159       {
45160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45161       };
45162     } catch (std::exception& e) {
45163       {
45164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45165       };
45166     } catch (Dali::DaliException e) {
45167       {
45168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45169       };
45170     } catch (...) {
45171       {
45172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45173       };
45174     }
45175   }
45176
45177   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45178
45179
45180   return jresult;
45181 }
45182
45183
45184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45185   void * jresult ;
45186   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45187   unsigned int arg2 ;
45188   unsigned int arg3 ;
45189   Dali::Pixel::Format arg4 ;
45190   Dali::BufferImage result;
45191
45192   arg1 = jarg1;
45193   arg2 = (unsigned int)jarg2;
45194   arg3 = (unsigned int)jarg3;
45195   arg4 = (Dali::Pixel::Format)jarg4;
45196   {
45197     try {
45198       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45199     } catch (std::out_of_range& e) {
45200       {
45201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45202       };
45203     } catch (std::exception& e) {
45204       {
45205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45206       };
45207     } catch (Dali::DaliException e) {
45208       {
45209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45210       };
45211     } catch (...) {
45212       {
45213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45214       };
45215     }
45216   }
45217
45218   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45219
45220
45221   return jresult;
45222 }
45223
45224
45225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45226   void * jresult ;
45227   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45228   unsigned int arg2 ;
45229   unsigned int arg3 ;
45230   Dali::BufferImage result;
45231
45232   arg1 = jarg1;
45233   arg2 = (unsigned int)jarg2;
45234   arg3 = (unsigned int)jarg3;
45235   {
45236     try {
45237       result = Dali::BufferImage::New(arg1,arg2,arg3);
45238     } catch (std::out_of_range& e) {
45239       {
45240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45241       };
45242     } catch (std::exception& e) {
45243       {
45244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45245       };
45246     } catch (Dali::DaliException e) {
45247       {
45248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45249       };
45250     } catch (...) {
45251       {
45252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45253       };
45254     }
45255   }
45256
45257   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45258
45259
45260   return jresult;
45261 }
45262
45263
45264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45265   void * jresult ;
45266   Dali::BaseHandle arg1 ;
45267   Dali::BaseHandle *argp1 ;
45268   Dali::BufferImage result;
45269
45270   argp1 = (Dali::BaseHandle *)jarg1;
45271   if (!argp1) {
45272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45273     return 0;
45274   }
45275   arg1 = *argp1;
45276   {
45277     try {
45278       result = Dali::BufferImage::DownCast(arg1);
45279     } catch (std::out_of_range& e) {
45280       {
45281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45282       };
45283     } catch (std::exception& e) {
45284       {
45285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45286       };
45287     } catch (Dali::DaliException e) {
45288       {
45289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45290       };
45291     } catch (...) {
45292       {
45293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45294       };
45295     }
45296   }
45297
45298   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45299   return jresult;
45300 }
45301
45302
45303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45304   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45305
45306   arg1 = (Dali::BufferImage *)jarg1;
45307   {
45308     try {
45309       delete arg1;
45310     } catch (std::out_of_range& e) {
45311       {
45312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45313       };
45314     } catch (std::exception& e) {
45315       {
45316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45317       };
45318     } catch (Dali::DaliException e) {
45319       {
45320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45321       };
45322     } catch (...) {
45323       {
45324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45325       };
45326     }
45327   }
45328
45329 }
45330
45331
45332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45333   void * jresult ;
45334   Dali::BufferImage *arg1 = 0 ;
45335   Dali::BufferImage *result = 0 ;
45336
45337   arg1 = (Dali::BufferImage *)jarg1;
45338   if (!arg1) {
45339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45340     return 0;
45341   }
45342   {
45343     try {
45344       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45345     } catch (std::out_of_range& e) {
45346       {
45347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45348       };
45349     } catch (std::exception& e) {
45350       {
45351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45352       };
45353     } catch (Dali::DaliException e) {
45354       {
45355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45356       };
45357     } catch (...) {
45358       {
45359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45360       };
45361     }
45362   }
45363
45364   jresult = (void *)result;
45365   return jresult;
45366 }
45367
45368
45369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45370   void * jresult ;
45371   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45372   Dali::BufferImage *arg2 = 0 ;
45373   Dali::BufferImage *result = 0 ;
45374
45375   arg1 = (Dali::BufferImage *)jarg1;
45376   arg2 = (Dali::BufferImage *)jarg2;
45377   if (!arg2) {
45378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45379     return 0;
45380   }
45381   {
45382     try {
45383       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45384     } catch (std::out_of_range& e) {
45385       {
45386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45387       };
45388     } catch (std::exception& e) {
45389       {
45390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45391       };
45392     } catch (Dali::DaliException e) {
45393       {
45394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45395       };
45396     } catch (...) {
45397       {
45398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45399       };
45400     }
45401   }
45402
45403   jresult = (void *)result;
45404   return jresult;
45405 }
45406
45407
45408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45409   void * jresult ;
45410   Dali::BufferImage result;
45411
45412   {
45413     try {
45414       result = Dali::BufferImage::WHITE();
45415     } catch (std::out_of_range& e) {
45416       {
45417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45418       };
45419     } catch (std::exception& e) {
45420       {
45421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45422       };
45423     } catch (Dali::DaliException e) {
45424       {
45425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45426       };
45427     } catch (...) {
45428       {
45429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45430       };
45431     }
45432   }
45433
45434   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45435   return jresult;
45436 }
45437
45438
45439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45440   void * jresult ;
45441   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45442   Dali::PixelBuffer *result = 0 ;
45443
45444   arg1 = (Dali::BufferImage *)jarg1;
45445   {
45446     try {
45447       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45448     } catch (std::out_of_range& e) {
45449       {
45450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45451       };
45452     } catch (std::exception& e) {
45453       {
45454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45455       };
45456     } catch (Dali::DaliException e) {
45457       {
45458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45459       };
45460     } catch (...) {
45461       {
45462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45463       };
45464     }
45465   }
45466
45467   jresult = (void *)result;
45468   return jresult;
45469 }
45470
45471
45472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45473   unsigned int jresult ;
45474   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45475   unsigned int result;
45476
45477   arg1 = (Dali::BufferImage *)jarg1;
45478   {
45479     try {
45480       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45481     } catch (std::out_of_range& e) {
45482       {
45483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45484       };
45485     } catch (std::exception& e) {
45486       {
45487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45488       };
45489     } catch (Dali::DaliException e) {
45490       {
45491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45492       };
45493     } catch (...) {
45494       {
45495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45496       };
45497     }
45498   }
45499
45500   jresult = result;
45501   return jresult;
45502 }
45503
45504
45505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45506   unsigned int jresult ;
45507   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45508   unsigned int result;
45509
45510   arg1 = (Dali::BufferImage *)jarg1;
45511   {
45512     try {
45513       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45514     } catch (std::out_of_range& e) {
45515       {
45516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45517       };
45518     } catch (std::exception& e) {
45519       {
45520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45521       };
45522     } catch (Dali::DaliException e) {
45523       {
45524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45525       };
45526     } catch (...) {
45527       {
45528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45529       };
45530     }
45531   }
45532
45533   jresult = result;
45534   return jresult;
45535 }
45536
45537
45538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45539   int jresult ;
45540   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45541   Dali::Pixel::Format result;
45542
45543   arg1 = (Dali::BufferImage *)jarg1;
45544   {
45545     try {
45546       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45547     } catch (std::out_of_range& e) {
45548       {
45549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45550       };
45551     } catch (std::exception& e) {
45552       {
45553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45554       };
45555     } catch (Dali::DaliException e) {
45556       {
45557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45558       };
45559     } catch (...) {
45560       {
45561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45562       };
45563     }
45564   }
45565
45566   jresult = (int)result;
45567   return jresult;
45568 }
45569
45570
45571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45572   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45573
45574   arg1 = (Dali::BufferImage *)jarg1;
45575   {
45576     try {
45577       (arg1)->Update();
45578     } catch (std::out_of_range& e) {
45579       {
45580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45581       };
45582     } catch (std::exception& e) {
45583       {
45584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45585       };
45586     } catch (Dali::DaliException e) {
45587       {
45588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45589       };
45590     } catch (...) {
45591       {
45592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45593       };
45594     }
45595   }
45596
45597 }
45598
45599
45600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45601   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45602   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45603   Dali::RectArea *argp2 ;
45604
45605   arg1 = (Dali::BufferImage *)jarg1;
45606   argp2 = (Dali::RectArea *)jarg2;
45607   if (!argp2) {
45608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45609     return ;
45610   }
45611   arg2 = *argp2;
45612   {
45613     try {
45614       (arg1)->Update(arg2);
45615     } catch (std::out_of_range& e) {
45616       {
45617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45618       };
45619     } catch (std::exception& e) {
45620       {
45621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45622       };
45623     } catch (Dali::DaliException e) {
45624       {
45625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45626       };
45627     } catch (...) {
45628       {
45629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45630       };
45631     }
45632   }
45633
45634 }
45635
45636
45637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45638   unsigned int jresult ;
45639   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45640   bool result;
45641
45642   arg1 = (Dali::BufferImage *)jarg1;
45643   {
45644     try {
45645       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45646     } catch (std::out_of_range& e) {
45647       {
45648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45649       };
45650     } catch (std::exception& e) {
45651       {
45652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45653       };
45654     } catch (Dali::DaliException e) {
45655       {
45656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45657       };
45658     } catch (...) {
45659       {
45660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45661       };
45662     }
45663   }
45664
45665   jresult = result;
45666   return jresult;
45667 }
45668
45669
45670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45671   void * jresult ;
45672   Dali::EncodedBufferImage *result = 0 ;
45673
45674   {
45675     try {
45676       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45677     } catch (std::out_of_range& e) {
45678       {
45679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45680       };
45681     } catch (std::exception& e) {
45682       {
45683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45684       };
45685     } catch (Dali::DaliException e) {
45686       {
45687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45688       };
45689     } catch (...) {
45690       {
45691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45692       };
45693     }
45694   }
45695
45696   jresult = (void *)result;
45697   return jresult;
45698 }
45699
45700
45701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45702   void * jresult ;
45703   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45704   std::size_t arg2 ;
45705   Dali::EncodedBufferImage result;
45706
45707   arg1 = (uint8_t *)jarg1;
45708   arg2 = (std::size_t)jarg2;
45709   {
45710     try {
45711       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45712     } catch (std::out_of_range& e) {
45713       {
45714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45715       };
45716     } catch (std::exception& e) {
45717       {
45718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45719       };
45720     } catch (Dali::DaliException e) {
45721       {
45722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45723       };
45724     } catch (...) {
45725       {
45726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45727       };
45728     }
45729   }
45730
45731   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45732   return jresult;
45733 }
45734
45735
45736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45737   void * jresult ;
45738   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45739   std::size_t arg2 ;
45740   Dali::ImageDimensions arg3 ;
45741   Dali::FittingMode::Type arg4 ;
45742   Dali::SamplingMode::Type arg5 ;
45743   bool arg6 ;
45744   Dali::ImageDimensions *argp3 ;
45745   Dali::EncodedBufferImage result;
45746
45747   arg1 = (uint8_t *)jarg1;
45748   arg2 = (std::size_t)jarg2;
45749   argp3 = (Dali::ImageDimensions *)jarg3;
45750   if (!argp3) {
45751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45752     return 0;
45753   }
45754   arg3 = *argp3;
45755   arg4 = (Dali::FittingMode::Type)jarg4;
45756   arg5 = (Dali::SamplingMode::Type)jarg5;
45757   arg6 = jarg6 ? true : false;
45758   {
45759     try {
45760       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45761     } catch (std::out_of_range& e) {
45762       {
45763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45764       };
45765     } catch (std::exception& e) {
45766       {
45767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45768       };
45769     } catch (Dali::DaliException e) {
45770       {
45771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45772       };
45773     } catch (...) {
45774       {
45775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45776       };
45777     }
45778   }
45779
45780   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45781   return jresult;
45782 }
45783
45784
45785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45786   void * jresult ;
45787   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45788   std::size_t arg2 ;
45789   Dali::ImageDimensions arg3 ;
45790   Dali::FittingMode::Type arg4 ;
45791   Dali::SamplingMode::Type arg5 ;
45792   Dali::ImageDimensions *argp3 ;
45793   Dali::EncodedBufferImage result;
45794
45795   arg1 = (uint8_t *)jarg1;
45796   arg2 = (std::size_t)jarg2;
45797   argp3 = (Dali::ImageDimensions *)jarg3;
45798   if (!argp3) {
45799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45800     return 0;
45801   }
45802   arg3 = *argp3;
45803   arg4 = (Dali::FittingMode::Type)jarg4;
45804   arg5 = (Dali::SamplingMode::Type)jarg5;
45805   {
45806     try {
45807       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45808     } catch (std::out_of_range& e) {
45809       {
45810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45811       };
45812     } catch (std::exception& e) {
45813       {
45814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45815       };
45816     } catch (Dali::DaliException e) {
45817       {
45818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45819       };
45820     } catch (...) {
45821       {
45822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45823       };
45824     }
45825   }
45826
45827   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45828   return jresult;
45829 }
45830
45831
45832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45833   void * jresult ;
45834   Dali::BaseHandle arg1 ;
45835   Dali::BaseHandle *argp1 ;
45836   Dali::EncodedBufferImage result;
45837
45838   argp1 = (Dali::BaseHandle *)jarg1;
45839   if (!argp1) {
45840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45841     return 0;
45842   }
45843   arg1 = *argp1;
45844   {
45845     try {
45846       result = Dali::EncodedBufferImage::DownCast(arg1);
45847     } catch (std::out_of_range& e) {
45848       {
45849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45850       };
45851     } catch (std::exception& e) {
45852       {
45853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45854       };
45855     } catch (Dali::DaliException e) {
45856       {
45857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45858       };
45859     } catch (...) {
45860       {
45861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45862       };
45863     }
45864   }
45865
45866   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45867   return jresult;
45868 }
45869
45870
45871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45872   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45873
45874   arg1 = (Dali::EncodedBufferImage *)jarg1;
45875   {
45876     try {
45877       delete arg1;
45878     } catch (std::out_of_range& e) {
45879       {
45880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45881       };
45882     } catch (std::exception& e) {
45883       {
45884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45885       };
45886     } catch (Dali::DaliException e) {
45887       {
45888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45889       };
45890     } catch (...) {
45891       {
45892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45893       };
45894     }
45895   }
45896
45897 }
45898
45899
45900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45901   void * jresult ;
45902   Dali::EncodedBufferImage *arg1 = 0 ;
45903   Dali::EncodedBufferImage *result = 0 ;
45904
45905   arg1 = (Dali::EncodedBufferImage *)jarg1;
45906   if (!arg1) {
45907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45908     return 0;
45909   }
45910   {
45911     try {
45912       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45913     } catch (std::out_of_range& e) {
45914       {
45915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45916       };
45917     } catch (std::exception& e) {
45918       {
45919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45920       };
45921     } catch (Dali::DaliException e) {
45922       {
45923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45924       };
45925     } catch (...) {
45926       {
45927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45928       };
45929     }
45930   }
45931
45932   jresult = (void *)result;
45933   return jresult;
45934 }
45935
45936
45937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45938   void * jresult ;
45939   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45940   Dali::EncodedBufferImage *arg2 = 0 ;
45941   Dali::EncodedBufferImage *result = 0 ;
45942
45943   arg1 = (Dali::EncodedBufferImage *)jarg1;
45944   arg2 = (Dali::EncodedBufferImage *)jarg2;
45945   if (!arg2) {
45946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45947     return 0;
45948   }
45949   {
45950     try {
45951       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45952     } catch (std::out_of_range& e) {
45953       {
45954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45955       };
45956     } catch (std::exception& e) {
45957       {
45958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45959       };
45960     } catch (Dali::DaliException e) {
45961       {
45962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45963       };
45964     } catch (...) {
45965       {
45966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45967       };
45968     }
45969   }
45970
45971   jresult = (void *)result;
45972   return jresult;
45973 }
45974
45975
45976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45977   void * jresult ;
45978   Dali::NativeImage *result = 0 ;
45979
45980   {
45981     try {
45982       result = (Dali::NativeImage *)new Dali::NativeImage();
45983     } catch (std::out_of_range& e) {
45984       {
45985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45986       };
45987     } catch (std::exception& e) {
45988       {
45989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45990       };
45991     } catch (Dali::DaliException e) {
45992       {
45993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45994       };
45995     } catch (...) {
45996       {
45997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45998       };
45999     }
46000   }
46001
46002   jresult = (void *)result;
46003   return jresult;
46004 }
46005
46006
46007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46008   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46009
46010   arg1 = (Dali::NativeImage *)jarg1;
46011   {
46012     try {
46013       delete arg1;
46014     } catch (std::out_of_range& e) {
46015       {
46016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46017       };
46018     } catch (std::exception& e) {
46019       {
46020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46021       };
46022     } catch (Dali::DaliException e) {
46023       {
46024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46025       };
46026     } catch (...) {
46027       {
46028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46029       };
46030     }
46031   }
46032
46033 }
46034
46035
46036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46037   void * jresult ;
46038   Dali::NativeImage *arg1 = 0 ;
46039   Dali::NativeImage *result = 0 ;
46040
46041   arg1 = (Dali::NativeImage *)jarg1;
46042   if (!arg1) {
46043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46044     return 0;
46045   }
46046   {
46047     try {
46048       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46049     } catch (std::out_of_range& e) {
46050       {
46051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46052       };
46053     } catch (std::exception& e) {
46054       {
46055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46056       };
46057     } catch (Dali::DaliException e) {
46058       {
46059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46060       };
46061     } catch (...) {
46062       {
46063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46064       };
46065     }
46066   }
46067
46068   jresult = (void *)result;
46069   return jresult;
46070 }
46071
46072
46073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46074   void * jresult ;
46075   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46076   Dali::NativeImage *arg2 = 0 ;
46077   Dali::NativeImage *result = 0 ;
46078
46079   arg1 = (Dali::NativeImage *)jarg1;
46080   arg2 = (Dali::NativeImage *)jarg2;
46081   if (!arg2) {
46082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46083     return 0;
46084   }
46085   {
46086     try {
46087       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46088     } catch (std::out_of_range& e) {
46089       {
46090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46091       };
46092     } catch (std::exception& e) {
46093       {
46094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46095       };
46096     } catch (Dali::DaliException e) {
46097       {
46098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46099       };
46100     } catch (...) {
46101       {
46102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46103       };
46104     }
46105   }
46106
46107   jresult = (void *)result;
46108   return jresult;
46109 }
46110
46111
46112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46113   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46114
46115   arg1 = (Dali::NativeImage *)jarg1;
46116   {
46117     try {
46118       (arg1)->CreateGlTexture();
46119     } catch (std::out_of_range& e) {
46120       {
46121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46122       };
46123     } catch (std::exception& e) {
46124       {
46125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46126       };
46127     } catch (Dali::DaliException e) {
46128       {
46129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46130       };
46131     } catch (...) {
46132       {
46133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46134       };
46135     }
46136   }
46137
46138 }
46139
46140
46141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46142   void * jresult ;
46143   NativeImageInterface *arg1 = 0 ;
46144   Dali::NativeImage result;
46145
46146   arg1 = (NativeImageInterface *)jarg1;
46147   if (!arg1) {
46148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46149     return 0;
46150   }
46151   {
46152     try {
46153       result = Dali::NativeImage::New(*arg1);
46154     } catch (std::out_of_range& e) {
46155       {
46156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46157       };
46158     } catch (std::exception& e) {
46159       {
46160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46161       };
46162     } catch (Dali::DaliException e) {
46163       {
46164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46165       };
46166     } catch (...) {
46167       {
46168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46169       };
46170     }
46171   }
46172
46173   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46174   return jresult;
46175 }
46176
46177
46178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46179   void * jresult ;
46180   Dali::BaseHandle arg1 ;
46181   Dali::BaseHandle *argp1 ;
46182   Dali::NativeImage result;
46183
46184   argp1 = (Dali::BaseHandle *)jarg1;
46185   if (!argp1) {
46186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46187     return 0;
46188   }
46189   arg1 = *argp1;
46190   {
46191     try {
46192       result = Dali::NativeImage::DownCast(arg1);
46193     } catch (std::out_of_range& e) {
46194       {
46195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46196       };
46197     } catch (std::exception& e) {
46198       {
46199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46200       };
46201     } catch (Dali::DaliException e) {
46202       {
46203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46204       };
46205     } catch (...) {
46206       {
46207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46208       };
46209     }
46210   }
46211
46212   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46213   return jresult;
46214 }
46215
46216
46217 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46218   char * jresult ;
46219   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46220   char *result = 0 ;
46221
46222   arg1 = (Dali::NativeImage *)jarg1;
46223   {
46224     try {
46225       result = (char *)(arg1)->GetCustomFragmentPreFix();
46226     } catch (std::out_of_range& e) {
46227       {
46228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46229       };
46230     } catch (std::exception& e) {
46231       {
46232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46233       };
46234     } catch (Dali::DaliException e) {
46235       {
46236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46237       };
46238     } catch (...) {
46239       {
46240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46241       };
46242     }
46243   }
46244
46245   jresult = SWIG_csharp_string_callback((const char *)result);
46246   return jresult;
46247 }
46248
46249
46250 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46251   char * jresult ;
46252   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46253   char *result = 0 ;
46254
46255   arg1 = (Dali::NativeImage *)jarg1;
46256   {
46257     try {
46258       result = (char *)(arg1)->GetCustomSamplerTypename();
46259     } catch (std::out_of_range& e) {
46260       {
46261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46262       };
46263     } catch (std::exception& e) {
46264       {
46265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46266       };
46267     } catch (Dali::DaliException e) {
46268       {
46269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46270       };
46271     } catch (...) {
46272       {
46273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46274       };
46275     }
46276   }
46277
46278   jresult = SWIG_csharp_string_callback((const char *)result);
46279   return jresult;
46280 }
46281
46282
46283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46284   unsigned int jresult ;
46285   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46286   bool result;
46287
46288   arg1 = (Dali::NativeImageInterface *)jarg1;
46289   {
46290     try {
46291       result = (bool)(arg1)->GlExtensionCreate();
46292     } catch (std::out_of_range& e) {
46293       {
46294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46295       };
46296     } catch (std::exception& e) {
46297       {
46298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46299       };
46300     } catch (Dali::DaliException e) {
46301       {
46302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46303       };
46304     } catch (...) {
46305       {
46306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46307       };
46308     }
46309   }
46310
46311   jresult = result;
46312   return jresult;
46313 }
46314
46315
46316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46317   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46318
46319   arg1 = (Dali::NativeImageInterface *)jarg1;
46320   {
46321     try {
46322       (arg1)->GlExtensionDestroy();
46323     } catch (std::out_of_range& e) {
46324       {
46325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46326       };
46327     } catch (std::exception& e) {
46328       {
46329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46330       };
46331     } catch (Dali::DaliException e) {
46332       {
46333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46334       };
46335     } catch (...) {
46336       {
46337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46338       };
46339     }
46340   }
46341
46342 }
46343
46344
46345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46346   unsigned int jresult ;
46347   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46348   unsigned int result;
46349
46350   arg1 = (Dali::NativeImageInterface *)jarg1;
46351   {
46352     try {
46353       result = (unsigned int)(arg1)->TargetTexture();
46354     } catch (std::out_of_range& e) {
46355       {
46356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46357       };
46358     } catch (std::exception& e) {
46359       {
46360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46361       };
46362     } catch (Dali::DaliException e) {
46363       {
46364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46365       };
46366     } catch (...) {
46367       {
46368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46369       };
46370     }
46371   }
46372
46373   jresult = result;
46374   return jresult;
46375 }
46376
46377
46378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46379   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46380
46381   arg1 = (Dali::NativeImageInterface *)jarg1;
46382   {
46383     try {
46384       (arg1)->PrepareTexture();
46385     } catch (std::out_of_range& e) {
46386       {
46387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46388       };
46389     } catch (std::exception& e) {
46390       {
46391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46392       };
46393     } catch (Dali::DaliException e) {
46394       {
46395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46396       };
46397     } catch (...) {
46398       {
46399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46400       };
46401     }
46402   }
46403
46404 }
46405
46406
46407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46408   unsigned int jresult ;
46409   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46410   unsigned int result;
46411
46412   arg1 = (Dali::NativeImageInterface *)jarg1;
46413   {
46414     try {
46415       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46416     } catch (std::out_of_range& e) {
46417       {
46418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46419       };
46420     } catch (std::exception& e) {
46421       {
46422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46423       };
46424     } catch (Dali::DaliException e) {
46425       {
46426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46427       };
46428     } catch (...) {
46429       {
46430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46431       };
46432     }
46433   }
46434
46435   jresult = result;
46436   return jresult;
46437 }
46438
46439
46440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46441   unsigned int jresult ;
46442   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46443   unsigned int result;
46444
46445   arg1 = (Dali::NativeImageInterface *)jarg1;
46446   {
46447     try {
46448       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46449     } catch (std::out_of_range& e) {
46450       {
46451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46452       };
46453     } catch (std::exception& e) {
46454       {
46455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46456       };
46457     } catch (Dali::DaliException e) {
46458       {
46459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46460       };
46461     } catch (...) {
46462       {
46463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46464       };
46465     }
46466   }
46467
46468   jresult = result;
46469   return jresult;
46470 }
46471
46472
46473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46474   unsigned int jresult ;
46475   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46476   bool result;
46477
46478   arg1 = (Dali::NativeImageInterface *)jarg1;
46479   {
46480     try {
46481       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46482     } catch (std::out_of_range& e) {
46483       {
46484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46485       };
46486     } catch (std::exception& e) {
46487       {
46488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46489       };
46490     } catch (Dali::DaliException e) {
46491       {
46492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46493       };
46494     } catch (...) {
46495       {
46496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46497       };
46498     }
46499   }
46500
46501   jresult = result;
46502   return jresult;
46503 }
46504
46505
46506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46507   void * jresult ;
46508   std::string *arg1 = 0 ;
46509   Dali::ImageDimensions result;
46510
46511   if (!jarg1) {
46512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46513     return 0;
46514   }
46515   std::string arg1_str(jarg1);
46516   arg1 = &arg1_str;
46517   {
46518     try {
46519       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46520     } catch (std::out_of_range& e) {
46521       {
46522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46523       };
46524     } catch (std::exception& e) {
46525       {
46526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46527       };
46528     } catch (Dali::DaliException e) {
46529       {
46530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46531       };
46532     } catch (...) {
46533       {
46534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46535       };
46536     }
46537   }
46538
46539   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46540
46541   //argout typemap for const std::string&
46542
46543   return jresult;
46544 }
46545
46546
46547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46548   void * jresult ;
46549   Dali::ResourceImage *result = 0 ;
46550
46551   {
46552     try {
46553       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46554     } catch (std::out_of_range& e) {
46555       {
46556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46557       };
46558     } catch (std::exception& e) {
46559       {
46560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46561       };
46562     } catch (Dali::DaliException e) {
46563       {
46564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46565       };
46566     } catch (...) {
46567       {
46568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46569       };
46570     }
46571   }
46572
46573   jresult = (void *)result;
46574   return jresult;
46575 }
46576
46577
46578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46579   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46580
46581   arg1 = (Dali::ResourceImage *)jarg1;
46582   {
46583     try {
46584       delete arg1;
46585     } catch (std::out_of_range& e) {
46586       {
46587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46588       };
46589     } catch (std::exception& e) {
46590       {
46591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46592       };
46593     } catch (Dali::DaliException e) {
46594       {
46595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46596       };
46597     } catch (...) {
46598       {
46599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46600       };
46601     }
46602   }
46603
46604 }
46605
46606
46607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46608   void * jresult ;
46609   Dali::ResourceImage *arg1 = 0 ;
46610   Dali::ResourceImage *result = 0 ;
46611
46612   arg1 = (Dali::ResourceImage *)jarg1;
46613   if (!arg1) {
46614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46615     return 0;
46616   }
46617   {
46618     try {
46619       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46620     } catch (std::out_of_range& e) {
46621       {
46622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46623       };
46624     } catch (std::exception& e) {
46625       {
46626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46627       };
46628     } catch (Dali::DaliException e) {
46629       {
46630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46631       };
46632     } catch (...) {
46633       {
46634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46635       };
46636     }
46637   }
46638
46639   jresult = (void *)result;
46640   return jresult;
46641 }
46642
46643
46644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46645   void * jresult ;
46646   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46647   Dali::ResourceImage *arg2 = 0 ;
46648   Dali::ResourceImage *result = 0 ;
46649
46650   arg1 = (Dali::ResourceImage *)jarg1;
46651   arg2 = (Dali::ResourceImage *)jarg2;
46652   if (!arg2) {
46653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46654     return 0;
46655   }
46656   {
46657     try {
46658       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46659     } catch (std::out_of_range& e) {
46660       {
46661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46662       };
46663     } catch (std::exception& e) {
46664       {
46665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46666       };
46667     } catch (Dali::DaliException e) {
46668       {
46669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46670       };
46671     } catch (...) {
46672       {
46673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46674       };
46675     }
46676   }
46677
46678   jresult = (void *)result;
46679   return jresult;
46680 }
46681
46682
46683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46684   void * jresult ;
46685   std::string *arg1 = 0 ;
46686   bool arg2 ;
46687   Dali::ResourceImage result;
46688
46689   if (!jarg1) {
46690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46691     return 0;
46692   }
46693   std::string arg1_str(jarg1);
46694   arg1 = &arg1_str;
46695   arg2 = jarg2 ? true : false;
46696   {
46697     try {
46698       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46699     } catch (std::out_of_range& e) {
46700       {
46701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46702       };
46703     } catch (std::exception& e) {
46704       {
46705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46706       };
46707     } catch (Dali::DaliException e) {
46708       {
46709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46710       };
46711     } catch (...) {
46712       {
46713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46714       };
46715     }
46716   }
46717
46718   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46719
46720   //argout typemap for const std::string&
46721
46722   return jresult;
46723 }
46724
46725
46726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46727   void * jresult ;
46728   std::string *arg1 = 0 ;
46729   Dali::ResourceImage result;
46730
46731   if (!jarg1) {
46732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46733     return 0;
46734   }
46735   std::string arg1_str(jarg1);
46736   arg1 = &arg1_str;
46737   {
46738     try {
46739       result = Dali::ResourceImage::New((std::string const &)*arg1);
46740     } catch (std::out_of_range& e) {
46741       {
46742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46743       };
46744     } catch (std::exception& e) {
46745       {
46746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46747       };
46748     } catch (Dali::DaliException e) {
46749       {
46750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46751       };
46752     } catch (...) {
46753       {
46754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46755       };
46756     }
46757   }
46758
46759   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46760
46761   //argout typemap for const std::string&
46762
46763   return jresult;
46764 }
46765
46766
46767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46768   void * jresult ;
46769   std::string *arg1 = 0 ;
46770   Dali::ImageDimensions arg2 ;
46771   Dali::FittingMode::Type arg3 ;
46772   Dali::SamplingMode::Type arg4 ;
46773   bool arg5 ;
46774   Dali::ImageDimensions *argp2 ;
46775   Dali::ResourceImage result;
46776
46777   if (!jarg1) {
46778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46779     return 0;
46780   }
46781   std::string arg1_str(jarg1);
46782   arg1 = &arg1_str;
46783   argp2 = (Dali::ImageDimensions *)jarg2;
46784   if (!argp2) {
46785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46786     return 0;
46787   }
46788   arg2 = *argp2;
46789   arg3 = (Dali::FittingMode::Type)jarg3;
46790   arg4 = (Dali::SamplingMode::Type)jarg4;
46791   arg5 = jarg5 ? true : false;
46792   {
46793     try {
46794       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46795     } catch (std::out_of_range& e) {
46796       {
46797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46798       };
46799     } catch (std::exception& e) {
46800       {
46801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46802       };
46803     } catch (Dali::DaliException e) {
46804       {
46805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46806       };
46807     } catch (...) {
46808       {
46809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46810       };
46811     }
46812   }
46813
46814   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46815
46816   //argout typemap for const std::string&
46817
46818   return jresult;
46819 }
46820
46821
46822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46823   void * jresult ;
46824   std::string *arg1 = 0 ;
46825   Dali::ImageDimensions arg2 ;
46826   Dali::FittingMode::Type arg3 ;
46827   Dali::SamplingMode::Type arg4 ;
46828   Dali::ImageDimensions *argp2 ;
46829   Dali::ResourceImage result;
46830
46831   if (!jarg1) {
46832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46833     return 0;
46834   }
46835   std::string arg1_str(jarg1);
46836   arg1 = &arg1_str;
46837   argp2 = (Dali::ImageDimensions *)jarg2;
46838   if (!argp2) {
46839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46840     return 0;
46841   }
46842   arg2 = *argp2;
46843   arg3 = (Dali::FittingMode::Type)jarg3;
46844   arg4 = (Dali::SamplingMode::Type)jarg4;
46845   {
46846     try {
46847       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46848     } catch (std::out_of_range& e) {
46849       {
46850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46851       };
46852     } catch (std::exception& e) {
46853       {
46854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46855       };
46856     } catch (Dali::DaliException e) {
46857       {
46858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46859       };
46860     } catch (...) {
46861       {
46862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46863       };
46864     }
46865   }
46866
46867   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46868
46869   //argout typemap for const std::string&
46870
46871   return jresult;
46872 }
46873
46874
46875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46876   void * jresult ;
46877   std::string *arg1 = 0 ;
46878   Dali::ImageDimensions arg2 ;
46879   Dali::FittingMode::Type arg3 ;
46880   Dali::ImageDimensions *argp2 ;
46881   Dali::ResourceImage result;
46882
46883   if (!jarg1) {
46884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46885     return 0;
46886   }
46887   std::string arg1_str(jarg1);
46888   arg1 = &arg1_str;
46889   argp2 = (Dali::ImageDimensions *)jarg2;
46890   if (!argp2) {
46891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46892     return 0;
46893   }
46894   arg2 = *argp2;
46895   arg3 = (Dali::FittingMode::Type)jarg3;
46896   {
46897     try {
46898       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46899     } catch (std::out_of_range& e) {
46900       {
46901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46902       };
46903     } catch (std::exception& e) {
46904       {
46905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46906       };
46907     } catch (Dali::DaliException e) {
46908       {
46909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46910       };
46911     } catch (...) {
46912       {
46913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46914       };
46915     }
46916   }
46917
46918   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46919
46920   //argout typemap for const std::string&
46921
46922   return jresult;
46923 }
46924
46925
46926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46927   void * jresult ;
46928   std::string *arg1 = 0 ;
46929   Dali::ImageDimensions arg2 ;
46930   Dali::ImageDimensions *argp2 ;
46931   Dali::ResourceImage result;
46932
46933   if (!jarg1) {
46934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46935     return 0;
46936   }
46937   std::string arg1_str(jarg1);
46938   arg1 = &arg1_str;
46939   argp2 = (Dali::ImageDimensions *)jarg2;
46940   if (!argp2) {
46941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46942     return 0;
46943   }
46944   arg2 = *argp2;
46945   {
46946     try {
46947       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46948     } catch (std::out_of_range& e) {
46949       {
46950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46951       };
46952     } catch (std::exception& e) {
46953       {
46954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46955       };
46956     } catch (Dali::DaliException e) {
46957       {
46958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46959       };
46960     } catch (...) {
46961       {
46962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46963       };
46964     }
46965   }
46966
46967   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46968
46969   //argout typemap for const std::string&
46970
46971   return jresult;
46972 }
46973
46974
46975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46976   void * jresult ;
46977   Dali::BaseHandle arg1 ;
46978   Dali::BaseHandle *argp1 ;
46979   Dali::ResourceImage result;
46980
46981   argp1 = (Dali::BaseHandle *)jarg1;
46982   if (!argp1) {
46983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46984     return 0;
46985   }
46986   arg1 = *argp1;
46987   {
46988     try {
46989       result = Dali::ResourceImage::DownCast(arg1);
46990     } catch (std::out_of_range& e) {
46991       {
46992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46993       };
46994     } catch (std::exception& e) {
46995       {
46996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46997       };
46998     } catch (Dali::DaliException e) {
46999       {
47000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47001       };
47002     } catch (...) {
47003       {
47004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47005       };
47006     }
47007   }
47008
47009   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47010   return jresult;
47011 }
47012
47013
47014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47015   int jresult ;
47016   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47017   Dali::LoadingState result;
47018
47019   arg1 = (Dali::ResourceImage *)jarg1;
47020   {
47021     try {
47022       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47023     } catch (std::out_of_range& e) {
47024       {
47025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47026       };
47027     } catch (std::exception& e) {
47028       {
47029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47030       };
47031     } catch (Dali::DaliException e) {
47032       {
47033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47034       };
47035     } catch (...) {
47036       {
47037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47038       };
47039     }
47040   }
47041
47042   jresult = (int)result;
47043   return jresult;
47044 }
47045
47046
47047 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47048   char * jresult ;
47049   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47050   std::string result;
47051
47052   arg1 = (Dali::ResourceImage *)jarg1;
47053   {
47054     try {
47055       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47056     } catch (std::out_of_range& e) {
47057       {
47058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47059       };
47060     } catch (std::exception& e) {
47061       {
47062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47063       };
47064     } catch (Dali::DaliException e) {
47065       {
47066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47067       };
47068     } catch (...) {
47069       {
47070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47071       };
47072     }
47073   }
47074
47075   jresult = SWIG_csharp_string_callback((&result)->c_str());
47076   return jresult;
47077 }
47078
47079
47080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47081   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47082
47083   arg1 = (Dali::ResourceImage *)jarg1;
47084   {
47085     try {
47086       (arg1)->Reload();
47087     } catch (std::out_of_range& e) {
47088       {
47089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47090       };
47091     } catch (std::exception& e) {
47092       {
47093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47094       };
47095     } catch (Dali::DaliException e) {
47096       {
47097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47098       };
47099     } catch (...) {
47100       {
47101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47102       };
47103     }
47104   }
47105
47106 }
47107
47108
47109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47110   void * jresult ;
47111   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47112   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47113
47114   arg1 = (Dali::ResourceImage *)jarg1;
47115   {
47116     try {
47117       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47118     } catch (std::out_of_range& e) {
47119       {
47120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47121       };
47122     } catch (std::exception& e) {
47123       {
47124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47125       };
47126     } catch (Dali::DaliException e) {
47127       {
47128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47129       };
47130     } catch (...) {
47131       {
47132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47133       };
47134     }
47135   }
47136
47137   jresult = (void *)result;
47138   return jresult;
47139 }
47140
47141
47142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47143   void * jresult ;
47144   Dali::FrameBufferImage *result = 0 ;
47145
47146   {
47147     try {
47148       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47149     } catch (std::out_of_range& e) {
47150       {
47151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47152       };
47153     } catch (std::exception& e) {
47154       {
47155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47156       };
47157     } catch (Dali::DaliException e) {
47158       {
47159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47160       };
47161     } catch (...) {
47162       {
47163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47164       };
47165     }
47166   }
47167
47168   jresult = (void *)result;
47169   return jresult;
47170 }
47171
47172
47173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47174   void * jresult ;
47175   unsigned int arg1 ;
47176   unsigned int arg2 ;
47177   Dali::Pixel::Format arg3 ;
47178   Dali::RenderBuffer::Format arg4 ;
47179   Dali::FrameBufferImage result;
47180
47181   arg1 = (unsigned int)jarg1;
47182   arg2 = (unsigned int)jarg2;
47183   arg3 = (Dali::Pixel::Format)jarg3;
47184   arg4 = (Dali::RenderBuffer::Format)jarg4;
47185   {
47186     try {
47187       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47188     } catch (std::out_of_range& e) {
47189       {
47190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47191       };
47192     } catch (std::exception& e) {
47193       {
47194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47195       };
47196     } catch (Dali::DaliException e) {
47197       {
47198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47199       };
47200     } catch (...) {
47201       {
47202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47203       };
47204     }
47205   }
47206
47207   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47208   return jresult;
47209 }
47210
47211
47212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47213   void * jresult ;
47214   unsigned int arg1 ;
47215   unsigned int arg2 ;
47216   Dali::Pixel::Format arg3 ;
47217   Dali::FrameBufferImage result;
47218
47219   arg1 = (unsigned int)jarg1;
47220   arg2 = (unsigned int)jarg2;
47221   arg3 = (Dali::Pixel::Format)jarg3;
47222   {
47223     try {
47224       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47225     } catch (std::out_of_range& e) {
47226       {
47227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47228       };
47229     } catch (std::exception& e) {
47230       {
47231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47232       };
47233     } catch (Dali::DaliException e) {
47234       {
47235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47236       };
47237     } catch (...) {
47238       {
47239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47240       };
47241     }
47242   }
47243
47244   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47245   return jresult;
47246 }
47247
47248
47249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47250   void * jresult ;
47251   unsigned int arg1 ;
47252   unsigned int arg2 ;
47253   Dali::FrameBufferImage result;
47254
47255   arg1 = (unsigned int)jarg1;
47256   arg2 = (unsigned int)jarg2;
47257   {
47258     try {
47259       result = Dali::FrameBufferImage::New(arg1,arg2);
47260     } catch (std::out_of_range& e) {
47261       {
47262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47263       };
47264     } catch (std::exception& e) {
47265       {
47266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47267       };
47268     } catch (Dali::DaliException e) {
47269       {
47270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47271       };
47272     } catch (...) {
47273       {
47274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47275       };
47276     }
47277   }
47278
47279   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47280   return jresult;
47281 }
47282
47283
47284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47285   void * jresult ;
47286   unsigned int arg1 ;
47287   Dali::FrameBufferImage result;
47288
47289   arg1 = (unsigned int)jarg1;
47290   {
47291     try {
47292       result = Dali::FrameBufferImage::New(arg1);
47293     } catch (std::out_of_range& e) {
47294       {
47295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47296       };
47297     } catch (std::exception& e) {
47298       {
47299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47300       };
47301     } catch (Dali::DaliException e) {
47302       {
47303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47304       };
47305     } catch (...) {
47306       {
47307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47308       };
47309     }
47310   }
47311
47312   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47313   return jresult;
47314 }
47315
47316
47317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47318   void * jresult ;
47319   Dali::FrameBufferImage result;
47320
47321   {
47322     try {
47323       result = Dali::FrameBufferImage::New();
47324     } catch (std::out_of_range& e) {
47325       {
47326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47327       };
47328     } catch (std::exception& e) {
47329       {
47330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47331       };
47332     } catch (Dali::DaliException e) {
47333       {
47334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47335       };
47336     } catch (...) {
47337       {
47338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47339       };
47340     }
47341   }
47342
47343   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47344   return jresult;
47345 }
47346
47347
47348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47349   void * jresult ;
47350   Dali::NativeImageInterface *arg1 = 0 ;
47351   Dali::FrameBufferImage result;
47352
47353   arg1 = (Dali::NativeImageInterface *)jarg1;
47354   if (!arg1) {
47355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47356     return 0;
47357   }
47358   {
47359     try {
47360       result = Dali::FrameBufferImage::New(*arg1);
47361     } catch (std::out_of_range& e) {
47362       {
47363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47364       };
47365     } catch (std::exception& e) {
47366       {
47367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47368       };
47369     } catch (Dali::DaliException e) {
47370       {
47371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47372       };
47373     } catch (...) {
47374       {
47375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47376       };
47377     }
47378   }
47379
47380   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47381   return jresult;
47382 }
47383
47384
47385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47386   void * jresult ;
47387   Dali::BaseHandle arg1 ;
47388   Dali::BaseHandle *argp1 ;
47389   Dali::FrameBufferImage result;
47390
47391   argp1 = (Dali::BaseHandle *)jarg1;
47392   if (!argp1) {
47393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47394     return 0;
47395   }
47396   arg1 = *argp1;
47397   {
47398     try {
47399       result = Dali::FrameBufferImage::DownCast(arg1);
47400     } catch (std::out_of_range& e) {
47401       {
47402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47403       };
47404     } catch (std::exception& e) {
47405       {
47406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47407       };
47408     } catch (Dali::DaliException e) {
47409       {
47410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47411       };
47412     } catch (...) {
47413       {
47414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47415       };
47416     }
47417   }
47418
47419   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47420   return jresult;
47421 }
47422
47423
47424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47425   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47426
47427   arg1 = (Dali::FrameBufferImage *)jarg1;
47428   {
47429     try {
47430       delete arg1;
47431     } catch (std::out_of_range& e) {
47432       {
47433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47434       };
47435     } catch (std::exception& e) {
47436       {
47437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47438       };
47439     } catch (Dali::DaliException e) {
47440       {
47441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47442       };
47443     } catch (...) {
47444       {
47445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47446       };
47447     }
47448   }
47449
47450 }
47451
47452
47453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47454   void * jresult ;
47455   Dali::FrameBufferImage *arg1 = 0 ;
47456   Dali::FrameBufferImage *result = 0 ;
47457
47458   arg1 = (Dali::FrameBufferImage *)jarg1;
47459   if (!arg1) {
47460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47461     return 0;
47462   }
47463   {
47464     try {
47465       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47466     } catch (std::out_of_range& e) {
47467       {
47468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47469       };
47470     } catch (std::exception& e) {
47471       {
47472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47473       };
47474     } catch (Dali::DaliException e) {
47475       {
47476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47477       };
47478     } catch (...) {
47479       {
47480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47481       };
47482     }
47483   }
47484
47485   jresult = (void *)result;
47486   return jresult;
47487 }
47488
47489
47490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47491   void * jresult ;
47492   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47493   Dali::FrameBufferImage *arg2 = 0 ;
47494   Dali::FrameBufferImage *result = 0 ;
47495
47496   arg1 = (Dali::FrameBufferImage *)jarg1;
47497   arg2 = (Dali::FrameBufferImage *)jarg2;
47498   if (!arg2) {
47499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47500     return 0;
47501   }
47502   {
47503     try {
47504       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47505     } catch (std::out_of_range& e) {
47506       {
47507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47508       };
47509     } catch (std::exception& e) {
47510       {
47511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47512       };
47513     } catch (Dali::DaliException e) {
47514       {
47515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47516       };
47517     } catch (...) {
47518       {
47519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47520       };
47521     }
47522   }
47523
47524   jresult = (void *)result;
47525   return jresult;
47526 }
47527
47528
47529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47530   void * jresult ;
47531   Dali::NinePatchImage *result = 0 ;
47532
47533   {
47534     try {
47535       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47536     } catch (std::out_of_range& e) {
47537       {
47538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47539       };
47540     } catch (std::exception& e) {
47541       {
47542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47543       };
47544     } catch (Dali::DaliException e) {
47545       {
47546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47547       };
47548     } catch (...) {
47549       {
47550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47551       };
47552     }
47553   }
47554
47555   jresult = (void *)result;
47556   return jresult;
47557 }
47558
47559
47560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47561   void * jresult ;
47562   std::string *arg1 = 0 ;
47563   Dali::NinePatchImage result;
47564
47565   if (!jarg1) {
47566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47567     return 0;
47568   }
47569   std::string arg1_str(jarg1);
47570   arg1 = &arg1_str;
47571   {
47572     try {
47573       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47574     } catch (std::out_of_range& e) {
47575       {
47576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47577       };
47578     } catch (std::exception& e) {
47579       {
47580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47581       };
47582     } catch (Dali::DaliException e) {
47583       {
47584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47585       };
47586     } catch (...) {
47587       {
47588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47589       };
47590     }
47591   }
47592
47593   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47594
47595   //argout typemap for const std::string&
47596
47597   return jresult;
47598 }
47599
47600
47601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47602   void * jresult ;
47603   Dali::BaseHandle arg1 ;
47604   Dali::BaseHandle *argp1 ;
47605   Dali::NinePatchImage result;
47606
47607   argp1 = (Dali::BaseHandle *)jarg1;
47608   if (!argp1) {
47609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47610     return 0;
47611   }
47612   arg1 = *argp1;
47613   {
47614     try {
47615       result = Dali::NinePatchImage::DownCast(arg1);
47616     } catch (std::out_of_range& e) {
47617       {
47618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47619       };
47620     } catch (std::exception& e) {
47621       {
47622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47623       };
47624     } catch (Dali::DaliException e) {
47625       {
47626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47627       };
47628     } catch (...) {
47629       {
47630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47631       };
47632     }
47633   }
47634
47635   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47636   return jresult;
47637 }
47638
47639
47640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47641   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47642
47643   arg1 = (Dali::NinePatchImage *)jarg1;
47644   {
47645     try {
47646       delete arg1;
47647     } catch (std::out_of_range& e) {
47648       {
47649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47650       };
47651     } catch (std::exception& e) {
47652       {
47653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47654       };
47655     } catch (Dali::DaliException e) {
47656       {
47657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47658       };
47659     } catch (...) {
47660       {
47661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47662       };
47663     }
47664   }
47665
47666 }
47667
47668
47669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47670   void * jresult ;
47671   Dali::NinePatchImage *arg1 = 0 ;
47672   Dali::NinePatchImage *result = 0 ;
47673
47674   arg1 = (Dali::NinePatchImage *)jarg1;
47675   if (!arg1) {
47676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47677     return 0;
47678   }
47679   {
47680     try {
47681       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47682     } catch (std::out_of_range& e) {
47683       {
47684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47685       };
47686     } catch (std::exception& e) {
47687       {
47688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47689       };
47690     } catch (Dali::DaliException e) {
47691       {
47692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47693       };
47694     } catch (...) {
47695       {
47696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47697       };
47698     }
47699   }
47700
47701   jresult = (void *)result;
47702   return jresult;
47703 }
47704
47705
47706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47707   void * jresult ;
47708   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47709   Dali::NinePatchImage *arg2 = 0 ;
47710   Dali::NinePatchImage *result = 0 ;
47711
47712   arg1 = (Dali::NinePatchImage *)jarg1;
47713   arg2 = (Dali::NinePatchImage *)jarg2;
47714   if (!arg2) {
47715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47716     return 0;
47717   }
47718   {
47719     try {
47720       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47721     } catch (std::out_of_range& e) {
47722       {
47723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47724       };
47725     } catch (std::exception& e) {
47726       {
47727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47728       };
47729     } catch (Dali::DaliException e) {
47730       {
47731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47732       };
47733     } catch (...) {
47734       {
47735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47736       };
47737     }
47738   }
47739
47740   jresult = (void *)result;
47741   return jresult;
47742 }
47743
47744
47745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47746   void * jresult ;
47747   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47748   Dali::Vector4 result;
47749
47750   arg1 = (Dali::NinePatchImage *)jarg1;
47751   {
47752     try {
47753       result = (arg1)->GetStretchBorders();
47754     } catch (std::out_of_range& e) {
47755       {
47756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47757       };
47758     } catch (std::exception& e) {
47759       {
47760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47761       };
47762     } catch (Dali::DaliException e) {
47763       {
47764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47765       };
47766     } catch (...) {
47767       {
47768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47769       };
47770     }
47771   }
47772
47773   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47774   return jresult;
47775 }
47776
47777
47778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47779   void * jresult ;
47780   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47781   Dali::NinePatchImage::StretchRanges *result = 0 ;
47782
47783   arg1 = (Dali::NinePatchImage *)jarg1;
47784   {
47785     try {
47786       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47787     } catch (std::out_of_range& e) {
47788       {
47789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47790       };
47791     } catch (std::exception& e) {
47792       {
47793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47794       };
47795     } catch (Dali::DaliException e) {
47796       {
47797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47798       };
47799     } catch (...) {
47800       {
47801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47802       };
47803     }
47804   }
47805
47806   jresult = (void *)result;
47807   return jresult;
47808 }
47809
47810
47811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47812   void * jresult ;
47813   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47814   Dali::NinePatchImage::StretchRanges *result = 0 ;
47815
47816   arg1 = (Dali::NinePatchImage *)jarg1;
47817   {
47818     try {
47819       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47820     } catch (std::out_of_range& e) {
47821       {
47822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47823       };
47824     } catch (std::exception& e) {
47825       {
47826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47827       };
47828     } catch (Dali::DaliException e) {
47829       {
47830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47831       };
47832     } catch (...) {
47833       {
47834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47835       };
47836     }
47837   }
47838
47839   jresult = (void *)result;
47840   return jresult;
47841 }
47842
47843
47844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47845   void * jresult ;
47846   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47847   Dali::Rect< int > result;
47848
47849   arg1 = (Dali::NinePatchImage *)jarg1;
47850   {
47851     try {
47852       result = (arg1)->GetChildRectangle();
47853     } catch (std::out_of_range& e) {
47854       {
47855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47856       };
47857     } catch (std::exception& e) {
47858       {
47859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47860       };
47861     } catch (Dali::DaliException e) {
47862       {
47863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47864       };
47865     } catch (...) {
47866       {
47867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47868       };
47869     }
47870   }
47871
47872   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47873   return jresult;
47874 }
47875
47876
47877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47878   void * jresult ;
47879   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47880   Dali::BufferImage result;
47881
47882   arg1 = (Dali::NinePatchImage *)jarg1;
47883   {
47884     try {
47885       result = (arg1)->CreateCroppedBufferImage();
47886     } catch (std::out_of_range& e) {
47887       {
47888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47889       };
47890     } catch (std::exception& e) {
47891       {
47892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47893       };
47894     } catch (Dali::DaliException e) {
47895       {
47896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47897       };
47898     } catch (...) {
47899       {
47900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47901       };
47902     }
47903   }
47904
47905   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47906   return jresult;
47907 }
47908
47909
47910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47911   unsigned int jresult ;
47912   std::string *arg1 = 0 ;
47913   bool result;
47914
47915   if (!jarg1) {
47916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47917     return 0;
47918   }
47919   std::string arg1_str(jarg1);
47920   arg1 = &arg1_str;
47921   {
47922     try {
47923       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47924     } catch (std::out_of_range& e) {
47925       {
47926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47927       };
47928     } catch (std::exception& e) {
47929       {
47930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47931       };
47932     } catch (Dali::DaliException e) {
47933       {
47934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47935       };
47936     } catch (...) {
47937       {
47938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47939       };
47940     }
47941   }
47942
47943   jresult = result;
47944
47945   //argout typemap for const std::string&
47946
47947   return jresult;
47948 }
47949
47950
47951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47952   int jresult ;
47953   int result;
47954
47955   result = (int)Dali::CameraActor::Property::TYPE;
47956   jresult = (int)result;
47957   return jresult;
47958 }
47959
47960
47961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47962   int jresult ;
47963   int result;
47964
47965   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47966   jresult = (int)result;
47967   return jresult;
47968 }
47969
47970
47971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47972   int jresult ;
47973   int result;
47974
47975   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47976   jresult = (int)result;
47977   return jresult;
47978 }
47979
47980
47981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47982   int jresult ;
47983   int result;
47984
47985   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47986   jresult = (int)result;
47987   return jresult;
47988 }
47989
47990
47991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47992   int jresult ;
47993   int result;
47994
47995   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47996   jresult = (int)result;
47997   return jresult;
47998 }
47999
48000
48001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48002   int jresult ;
48003   int result;
48004
48005   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48006   jresult = (int)result;
48007   return jresult;
48008 }
48009
48010
48011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48012   int jresult ;
48013   int result;
48014
48015   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48016   jresult = (int)result;
48017   return jresult;
48018 }
48019
48020
48021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48022   int jresult ;
48023   int result;
48024
48025   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48026   jresult = (int)result;
48027   return jresult;
48028 }
48029
48030
48031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48032   int jresult ;
48033   int result;
48034
48035   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48036   jresult = (int)result;
48037   return jresult;
48038 }
48039
48040
48041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48042   int jresult ;
48043   int result;
48044
48045   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48046   jresult = (int)result;
48047   return jresult;
48048 }
48049
48050
48051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48052   int jresult ;
48053   int result;
48054
48055   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48056   jresult = (int)result;
48057   return jresult;
48058 }
48059
48060
48061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48062   int jresult ;
48063   int result;
48064
48065   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48066   jresult = (int)result;
48067   return jresult;
48068 }
48069
48070
48071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48072   int jresult ;
48073   int result;
48074
48075   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48076   jresult = (int)result;
48077   return jresult;
48078 }
48079
48080
48081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48082   int jresult ;
48083   int result;
48084
48085   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48086   jresult = (int)result;
48087   return jresult;
48088 }
48089
48090
48091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48092   void * jresult ;
48093   Dali::CameraActor::Property *result = 0 ;
48094
48095   {
48096     try {
48097       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48098     } catch (std::out_of_range& e) {
48099       {
48100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48101       };
48102     } catch (std::exception& e) {
48103       {
48104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48105       };
48106     } catch (Dali::DaliException e) {
48107       {
48108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48109       };
48110     } catch (...) {
48111       {
48112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48113       };
48114     }
48115   }
48116
48117   jresult = (void *)result;
48118   return jresult;
48119 }
48120
48121
48122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48123   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48124
48125   arg1 = (Dali::CameraActor::Property *)jarg1;
48126   {
48127     try {
48128       delete arg1;
48129     } catch (std::out_of_range& e) {
48130       {
48131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48132       };
48133     } catch (std::exception& e) {
48134       {
48135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48136       };
48137     } catch (Dali::DaliException e) {
48138       {
48139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48140       };
48141     } catch (...) {
48142       {
48143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48144       };
48145     }
48146   }
48147
48148 }
48149
48150
48151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48152   void * jresult ;
48153   Dali::CameraActor *result = 0 ;
48154
48155   {
48156     try {
48157       result = (Dali::CameraActor *)new Dali::CameraActor();
48158     } catch (std::out_of_range& e) {
48159       {
48160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48161       };
48162     } catch (std::exception& e) {
48163       {
48164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48165       };
48166     } catch (Dali::DaliException e) {
48167       {
48168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48169       };
48170     } catch (...) {
48171       {
48172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48173       };
48174     }
48175   }
48176
48177   jresult = (void *)result;
48178   return jresult;
48179 }
48180
48181
48182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48183   void * jresult ;
48184   Dali::CameraActor result;
48185
48186   {
48187     try {
48188       result = Dali::CameraActor::New();
48189     } catch (std::out_of_range& e) {
48190       {
48191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48192       };
48193     } catch (std::exception& e) {
48194       {
48195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48196       };
48197     } catch (Dali::DaliException e) {
48198       {
48199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48200       };
48201     } catch (...) {
48202       {
48203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48204       };
48205     }
48206   }
48207
48208   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48209   return jresult;
48210 }
48211
48212
48213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48214   void * jresult ;
48215   Dali::Size *arg1 = 0 ;
48216   Dali::CameraActor result;
48217
48218   arg1 = (Dali::Size *)jarg1;
48219   if (!arg1) {
48220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48221     return 0;
48222   }
48223   {
48224     try {
48225       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48226     } catch (std::out_of_range& e) {
48227       {
48228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48229       };
48230     } catch (std::exception& e) {
48231       {
48232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48233       };
48234     } catch (Dali::DaliException e) {
48235       {
48236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48237       };
48238     } catch (...) {
48239       {
48240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48241       };
48242     }
48243   }
48244
48245   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48246   return jresult;
48247 }
48248
48249
48250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48251   void * jresult ;
48252   Dali::BaseHandle arg1 ;
48253   Dali::BaseHandle *argp1 ;
48254   Dali::CameraActor result;
48255
48256   argp1 = (Dali::BaseHandle *)jarg1;
48257   if (!argp1) {
48258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48259     return 0;
48260   }
48261   arg1 = *argp1;
48262   {
48263     try {
48264       result = Dali::CameraActor::DownCast(arg1);
48265     } catch (std::out_of_range& e) {
48266       {
48267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48268       };
48269     } catch (std::exception& e) {
48270       {
48271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48272       };
48273     } catch (Dali::DaliException e) {
48274       {
48275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48276       };
48277     } catch (...) {
48278       {
48279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48280       };
48281     }
48282   }
48283
48284   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48285   return jresult;
48286 }
48287
48288
48289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48290   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48291
48292   arg1 = (Dali::CameraActor *)jarg1;
48293   {
48294     try {
48295       delete arg1;
48296     } catch (std::out_of_range& e) {
48297       {
48298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48299       };
48300     } catch (std::exception& e) {
48301       {
48302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48303       };
48304     } catch (Dali::DaliException e) {
48305       {
48306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48307       };
48308     } catch (...) {
48309       {
48310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48311       };
48312     }
48313   }
48314
48315 }
48316
48317
48318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48319   void * jresult ;
48320   Dali::CameraActor *arg1 = 0 ;
48321   Dali::CameraActor *result = 0 ;
48322
48323   arg1 = (Dali::CameraActor *)jarg1;
48324   if (!arg1) {
48325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48326     return 0;
48327   }
48328   {
48329     try {
48330       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48331     } catch (std::out_of_range& e) {
48332       {
48333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48334       };
48335     } catch (std::exception& e) {
48336       {
48337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48338       };
48339     } catch (Dali::DaliException e) {
48340       {
48341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48342       };
48343     } catch (...) {
48344       {
48345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48346       };
48347     }
48348   }
48349
48350   jresult = (void *)result;
48351   return jresult;
48352 }
48353
48354
48355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48356   void * jresult ;
48357   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48358   Dali::CameraActor *arg2 = 0 ;
48359   Dali::CameraActor *result = 0 ;
48360
48361   arg1 = (Dali::CameraActor *)jarg1;
48362   arg2 = (Dali::CameraActor *)jarg2;
48363   if (!arg2) {
48364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48365     return 0;
48366   }
48367   {
48368     try {
48369       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48370     } catch (std::out_of_range& e) {
48371       {
48372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48373       };
48374     } catch (std::exception& e) {
48375       {
48376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48377       };
48378     } catch (Dali::DaliException e) {
48379       {
48380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48381       };
48382     } catch (...) {
48383       {
48384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48385       };
48386     }
48387   }
48388
48389   jresult = (void *)result;
48390   return jresult;
48391 }
48392
48393
48394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48395   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48396   Dali::Camera::Type arg2 ;
48397
48398   arg1 = (Dali::CameraActor *)jarg1;
48399   arg2 = (Dali::Camera::Type)jarg2;
48400   {
48401     try {
48402       (arg1)->SetType(arg2);
48403     } catch (std::out_of_range& e) {
48404       {
48405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48406       };
48407     } catch (std::exception& e) {
48408       {
48409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48410       };
48411     } catch (Dali::DaliException e) {
48412       {
48413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48414       };
48415     } catch (...) {
48416       {
48417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48418       };
48419     }
48420   }
48421
48422 }
48423
48424
48425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48426   int jresult ;
48427   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48428   Dali::Camera::Type result;
48429
48430   arg1 = (Dali::CameraActor *)jarg1;
48431   {
48432     try {
48433       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48434     } catch (std::out_of_range& e) {
48435       {
48436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48437       };
48438     } catch (std::exception& e) {
48439       {
48440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48441       };
48442     } catch (Dali::DaliException e) {
48443       {
48444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48445       };
48446     } catch (...) {
48447       {
48448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48449       };
48450     }
48451   }
48452
48453   jresult = (int)result;
48454   return jresult;
48455 }
48456
48457
48458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48459   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48460   Dali::Camera::ProjectionMode arg2 ;
48461
48462   arg1 = (Dali::CameraActor *)jarg1;
48463   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48464   {
48465     try {
48466       (arg1)->SetProjectionMode(arg2);
48467     } catch (std::out_of_range& e) {
48468       {
48469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48470       };
48471     } catch (std::exception& e) {
48472       {
48473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48474       };
48475     } catch (Dali::DaliException e) {
48476       {
48477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48478       };
48479     } catch (...) {
48480       {
48481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48482       };
48483     }
48484   }
48485
48486 }
48487
48488
48489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48490   int jresult ;
48491   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48492   Dali::Camera::ProjectionMode result;
48493
48494   arg1 = (Dali::CameraActor *)jarg1;
48495   {
48496     try {
48497       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48498     } catch (std::out_of_range& e) {
48499       {
48500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48501       };
48502     } catch (std::exception& e) {
48503       {
48504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48505       };
48506     } catch (Dali::DaliException e) {
48507       {
48508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48509       };
48510     } catch (...) {
48511       {
48512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48513       };
48514     }
48515   }
48516
48517   jresult = (int)result;
48518   return jresult;
48519 }
48520
48521
48522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48523   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48524   float arg2 ;
48525
48526   arg1 = (Dali::CameraActor *)jarg1;
48527   arg2 = (float)jarg2;
48528   {
48529     try {
48530       (arg1)->SetFieldOfView(arg2);
48531     } catch (std::out_of_range& e) {
48532       {
48533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48534       };
48535     } catch (std::exception& e) {
48536       {
48537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48538       };
48539     } catch (Dali::DaliException e) {
48540       {
48541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48542       };
48543     } catch (...) {
48544       {
48545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48546       };
48547     }
48548   }
48549
48550 }
48551
48552
48553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48554   float jresult ;
48555   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48556   float result;
48557
48558   arg1 = (Dali::CameraActor *)jarg1;
48559   {
48560     try {
48561       result = (float)(arg1)->GetFieldOfView();
48562     } catch (std::out_of_range& e) {
48563       {
48564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48565       };
48566     } catch (std::exception& e) {
48567       {
48568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48569       };
48570     } catch (Dali::DaliException e) {
48571       {
48572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48573       };
48574     } catch (...) {
48575       {
48576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48577       };
48578     }
48579   }
48580
48581   jresult = result;
48582   return jresult;
48583 }
48584
48585
48586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48587   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48588   float arg2 ;
48589
48590   arg1 = (Dali::CameraActor *)jarg1;
48591   arg2 = (float)jarg2;
48592   {
48593     try {
48594       (arg1)->SetAspectRatio(arg2);
48595     } catch (std::out_of_range& e) {
48596       {
48597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48598       };
48599     } catch (std::exception& e) {
48600       {
48601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48602       };
48603     } catch (Dali::DaliException e) {
48604       {
48605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48606       };
48607     } catch (...) {
48608       {
48609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48610       };
48611     }
48612   }
48613
48614 }
48615
48616
48617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48618   float jresult ;
48619   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48620   float result;
48621
48622   arg1 = (Dali::CameraActor *)jarg1;
48623   {
48624     try {
48625       result = (float)(arg1)->GetAspectRatio();
48626     } catch (std::out_of_range& e) {
48627       {
48628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48629       };
48630     } catch (std::exception& e) {
48631       {
48632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48633       };
48634     } catch (Dali::DaliException e) {
48635       {
48636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48637       };
48638     } catch (...) {
48639       {
48640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48641       };
48642     }
48643   }
48644
48645   jresult = result;
48646   return jresult;
48647 }
48648
48649
48650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48651   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48652   float arg2 ;
48653
48654   arg1 = (Dali::CameraActor *)jarg1;
48655   arg2 = (float)jarg2;
48656   {
48657     try {
48658       (arg1)->SetNearClippingPlane(arg2);
48659     } catch (std::out_of_range& e) {
48660       {
48661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48662       };
48663     } catch (std::exception& e) {
48664       {
48665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48666       };
48667     } catch (Dali::DaliException e) {
48668       {
48669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48670       };
48671     } catch (...) {
48672       {
48673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48674       };
48675     }
48676   }
48677
48678 }
48679
48680
48681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48682   float jresult ;
48683   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48684   float result;
48685
48686   arg1 = (Dali::CameraActor *)jarg1;
48687   {
48688     try {
48689       result = (float)(arg1)->GetNearClippingPlane();
48690     } catch (std::out_of_range& e) {
48691       {
48692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48693       };
48694     } catch (std::exception& e) {
48695       {
48696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48697       };
48698     } catch (Dali::DaliException e) {
48699       {
48700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48701       };
48702     } catch (...) {
48703       {
48704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48705       };
48706     }
48707   }
48708
48709   jresult = result;
48710   return jresult;
48711 }
48712
48713
48714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48715   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48716   float arg2 ;
48717
48718   arg1 = (Dali::CameraActor *)jarg1;
48719   arg2 = (float)jarg2;
48720   {
48721     try {
48722       (arg1)->SetFarClippingPlane(arg2);
48723     } catch (std::out_of_range& e) {
48724       {
48725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48726       };
48727     } catch (std::exception& e) {
48728       {
48729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48730       };
48731     } catch (Dali::DaliException e) {
48732       {
48733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48734       };
48735     } catch (...) {
48736       {
48737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48738       };
48739     }
48740   }
48741
48742 }
48743
48744
48745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48746   float jresult ;
48747   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48748   float result;
48749
48750   arg1 = (Dali::CameraActor *)jarg1;
48751   {
48752     try {
48753       result = (float)(arg1)->GetFarClippingPlane();
48754     } catch (std::out_of_range& e) {
48755       {
48756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48757       };
48758     } catch (std::exception& e) {
48759       {
48760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48761       };
48762     } catch (Dali::DaliException e) {
48763       {
48764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48765       };
48766     } catch (...) {
48767       {
48768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48769       };
48770     }
48771   }
48772
48773   jresult = result;
48774   return jresult;
48775 }
48776
48777
48778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48779   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48780   Dali::Vector3 *arg2 = 0 ;
48781
48782   arg1 = (Dali::CameraActor *)jarg1;
48783   arg2 = (Dali::Vector3 *)jarg2;
48784   if (!arg2) {
48785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48786     return ;
48787   }
48788   {
48789     try {
48790       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48791     } catch (std::out_of_range& e) {
48792       {
48793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48794       };
48795     } catch (std::exception& e) {
48796       {
48797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48798       };
48799     } catch (Dali::DaliException e) {
48800       {
48801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48802       };
48803     } catch (...) {
48804       {
48805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48806       };
48807     }
48808   }
48809
48810 }
48811
48812
48813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48814   void * jresult ;
48815   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48816   Dali::Vector3 result;
48817
48818   arg1 = (Dali::CameraActor *)jarg1;
48819   {
48820     try {
48821       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48822     } catch (std::out_of_range& e) {
48823       {
48824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48825       };
48826     } catch (std::exception& e) {
48827       {
48828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48829       };
48830     } catch (Dali::DaliException e) {
48831       {
48832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48833       };
48834     } catch (...) {
48835       {
48836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48837       };
48838     }
48839   }
48840
48841   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48842   return jresult;
48843 }
48844
48845
48846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48847   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48848   bool arg2 ;
48849
48850   arg1 = (Dali::CameraActor *)jarg1;
48851   arg2 = jarg2 ? true : false;
48852   {
48853     try {
48854       (arg1)->SetInvertYAxis(arg2);
48855     } catch (std::out_of_range& e) {
48856       {
48857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48858       };
48859     } catch (std::exception& e) {
48860       {
48861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48862       };
48863     } catch (Dali::DaliException e) {
48864       {
48865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48866       };
48867     } catch (...) {
48868       {
48869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48870       };
48871     }
48872   }
48873
48874 }
48875
48876
48877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48878   unsigned int jresult ;
48879   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48880   bool result;
48881
48882   arg1 = (Dali::CameraActor *)jarg1;
48883   {
48884     try {
48885       result = (bool)(arg1)->GetInvertYAxis();
48886     } catch (std::out_of_range& e) {
48887       {
48888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48889       };
48890     } catch (std::exception& e) {
48891       {
48892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48893       };
48894     } catch (Dali::DaliException e) {
48895       {
48896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48897       };
48898     } catch (...) {
48899       {
48900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48901       };
48902     }
48903   }
48904
48905   jresult = result;
48906   return jresult;
48907 }
48908
48909
48910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48911   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48912   Dali::Size *arg2 = 0 ;
48913
48914   arg1 = (Dali::CameraActor *)jarg1;
48915   arg2 = (Dali::Size *)jarg2;
48916   if (!arg2) {
48917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48918     return ;
48919   }
48920   {
48921     try {
48922       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48923     } catch (std::out_of_range& e) {
48924       {
48925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48926       };
48927     } catch (std::exception& e) {
48928       {
48929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48930       };
48931     } catch (Dali::DaliException e) {
48932       {
48933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48934       };
48935     } catch (...) {
48936       {
48937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48938       };
48939     }
48940   }
48941
48942 }
48943
48944
48945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48946   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48947   Dali::Size *arg2 = 0 ;
48948
48949   arg1 = (Dali::CameraActor *)jarg1;
48950   arg2 = (Dali::Size *)jarg2;
48951   if (!arg2) {
48952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48953     return ;
48954   }
48955   {
48956     try {
48957       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48958     } catch (std::out_of_range& e) {
48959       {
48960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48961       };
48962     } catch (std::exception& e) {
48963       {
48964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48965       };
48966     } catch (Dali::DaliException e) {
48967       {
48968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48969       };
48970     } catch (...) {
48971       {
48972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48973       };
48974     }
48975   }
48976
48977 }
48978
48979
48980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48981   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48982   float arg2 ;
48983   float arg3 ;
48984   float arg4 ;
48985   float arg5 ;
48986   float arg6 ;
48987   float arg7 ;
48988
48989   arg1 = (Dali::CameraActor *)jarg1;
48990   arg2 = (float)jarg2;
48991   arg3 = (float)jarg3;
48992   arg4 = (float)jarg4;
48993   arg5 = (float)jarg5;
48994   arg6 = (float)jarg6;
48995   arg7 = (float)jarg7;
48996   {
48997     try {
48998       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48999     } catch (std::out_of_range& e) {
49000       {
49001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49002       };
49003     } catch (std::exception& e) {
49004       {
49005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49006       };
49007     } catch (Dali::DaliException e) {
49008       {
49009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49010       };
49011     } catch (...) {
49012       {
49013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49014       };
49015     }
49016   }
49017
49018 }
49019
49020
49021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49022   void * jresult ;
49023   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49024
49025   {
49026     try {
49027       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49028     } catch (std::out_of_range& e) {
49029       {
49030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49031       };
49032     } catch (std::exception& e) {
49033       {
49034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49035       };
49036     } catch (Dali::DaliException e) {
49037       {
49038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49039       };
49040     } catch (...) {
49041       {
49042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49043       };
49044     }
49045   }
49046
49047   jresult = (void *)result;
49048   return jresult;
49049 }
49050
49051
49052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49053   void * jresult ;
49054   std::string arg1 ;
49055   Dali::Property::Value arg2 ;
49056   Dali::Property::Value *argp2 ;
49057   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49058
49059   if (!jarg1) {
49060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49061     return 0;
49062   }
49063   (&arg1)->assign(jarg1);
49064   argp2 = (Dali::Property::Value *)jarg2;
49065   if (!argp2) {
49066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49067     return 0;
49068   }
49069   arg2 = *argp2;
49070   {
49071     try {
49072       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49073     } catch (std::out_of_range& e) {
49074       {
49075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49076       };
49077     } catch (std::exception& e) {
49078       {
49079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49080       };
49081     } catch (Dali::DaliException e) {
49082       {
49083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49084       };
49085     } catch (...) {
49086       {
49087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49088       };
49089     }
49090   }
49091
49092   jresult = (void *)result;
49093   return jresult;
49094 }
49095
49096
49097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49098   void * jresult ;
49099   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49100   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49101
49102   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49103   if (!arg1) {
49104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49105     return 0;
49106   }
49107   {
49108     try {
49109       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);
49110     } catch (std::out_of_range& e) {
49111       {
49112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49113       };
49114     } catch (std::exception& e) {
49115       {
49116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49117       };
49118     } catch (Dali::DaliException e) {
49119       {
49120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49121       };
49122     } catch (...) {
49123       {
49124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49125       };
49126     }
49127   }
49128
49129   jresult = (void *)result;
49130   return jresult;
49131 }
49132
49133
49134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49135   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49136   std::string *arg2 = 0 ;
49137
49138   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49139   if (!jarg2) {
49140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49141     return ;
49142   }
49143   std::string arg2_str(jarg2);
49144   arg2 = &arg2_str;
49145   if (arg1) (arg1)->first = *arg2;
49146
49147   //argout typemap for const std::string&
49148
49149 }
49150
49151
49152 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49153   char * jresult ;
49154   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49155   std::string *result = 0 ;
49156
49157   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49158   result = (std::string *) & ((arg1)->first);
49159   jresult = SWIG_csharp_string_callback(result->c_str());
49160   return jresult;
49161 }
49162
49163
49164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49165   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49166   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49167
49168   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49169   arg2 = (Dali::Property::Value *)jarg2;
49170   if (arg1) (arg1)->second = *arg2;
49171 }
49172
49173
49174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49175   void * jresult ;
49176   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49177   Dali::Property::Value *result = 0 ;
49178
49179   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49180   result = (Dali::Property::Value *)& ((arg1)->second);
49181   jresult = (void *)result;
49182   return jresult;
49183 }
49184
49185
49186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49187   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49188
49189   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49190   {
49191     try {
49192       delete arg1;
49193     } catch (std::out_of_range& e) {
49194       {
49195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49196       };
49197     } catch (std::exception& e) {
49198       {
49199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49200       };
49201     } catch (Dali::DaliException e) {
49202       {
49203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49204       };
49205     } catch (...) {
49206       {
49207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49208       };
49209     }
49210   }
49211
49212 }
49213
49214
49215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49216   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49217
49218   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49219   {
49220     try {
49221       (arg1)->clear();
49222     } catch (std::out_of_range& e) {
49223       {
49224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49225       };
49226     } catch (std::exception& e) {
49227       {
49228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49229       };
49230     } catch (Dali::DaliException e) {
49231       {
49232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49233       };
49234     } catch (...) {
49235       {
49236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49237       };
49238     }
49239   }
49240
49241 }
49242
49243
49244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49245   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49246   Dali::TouchPoint *arg2 = 0 ;
49247
49248   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49249   arg2 = (Dali::TouchPoint *)jarg2;
49250   if (!arg2) {
49251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49252     return ;
49253   }
49254   {
49255     try {
49256       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49257     } catch (std::out_of_range& e) {
49258       {
49259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49260       };
49261     } catch (std::exception& e) {
49262       {
49263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49264       };
49265     } catch (Dali::DaliException e) {
49266       {
49267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49268       };
49269     } catch (...) {
49270       {
49271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49272       };
49273     }
49274   }
49275
49276 }
49277
49278
49279 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49280   unsigned long jresult ;
49281   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49282   std::vector< Dali::TouchPoint >::size_type result;
49283
49284   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49285   {
49286     try {
49287       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49288     } catch (std::out_of_range& e) {
49289       {
49290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49291       };
49292     } catch (std::exception& e) {
49293       {
49294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49295       };
49296     } catch (Dali::DaliException e) {
49297       {
49298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49299       };
49300     } catch (...) {
49301       {
49302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49303       };
49304     }
49305   }
49306
49307   jresult = (unsigned long)result;
49308   return jresult;
49309 }
49310
49311
49312 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49313   unsigned long jresult ;
49314   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49315   std::vector< Dali::TouchPoint >::size_type result;
49316
49317   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49318   {
49319     try {
49320       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49321     } catch (std::out_of_range& e) {
49322       {
49323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49324       };
49325     } catch (std::exception& e) {
49326       {
49327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49328       };
49329     } catch (Dali::DaliException e) {
49330       {
49331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49332       };
49333     } catch (...) {
49334       {
49335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49336       };
49337     }
49338   }
49339
49340   jresult = (unsigned long)result;
49341   return jresult;
49342 }
49343
49344
49345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49346   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49347   std::vector< Dali::TouchPoint >::size_type arg2 ;
49348
49349   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49350   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49351   {
49352     try {
49353       (arg1)->reserve(arg2);
49354     } catch (std::out_of_range& e) {
49355       {
49356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49357       };
49358     } catch (std::exception& e) {
49359       {
49360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49361       };
49362     } catch (Dali::DaliException e) {
49363       {
49364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49365       };
49366     } catch (...) {
49367       {
49368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49369       };
49370     }
49371   }
49372
49373 }
49374
49375
49376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49377   void * jresult ;
49378   std::vector< Dali::TouchPoint > *result = 0 ;
49379
49380   {
49381     try {
49382       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49383     } catch (std::out_of_range& e) {
49384       {
49385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49386       };
49387     } catch (std::exception& e) {
49388       {
49389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49390       };
49391     } catch (Dali::DaliException e) {
49392       {
49393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49394       };
49395     } catch (...) {
49396       {
49397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49398       };
49399     }
49400   }
49401
49402   jresult = (void *)result;
49403   return jresult;
49404 }
49405
49406
49407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49408   void * jresult ;
49409   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49410   std::vector< Dali::TouchPoint > *result = 0 ;
49411
49412   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49413   if (!arg1) {
49414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49415     return 0;
49416   }
49417   {
49418     try {
49419       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49420     } catch (std::out_of_range& e) {
49421       {
49422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49423       };
49424     } catch (std::exception& e) {
49425       {
49426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49427       };
49428     } catch (Dali::DaliException e) {
49429       {
49430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49431       };
49432     } catch (...) {
49433       {
49434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49435       };
49436     }
49437   }
49438
49439   jresult = (void *)result;
49440   return jresult;
49441 }
49442
49443
49444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49445   void * jresult ;
49446   int arg1 ;
49447   std::vector< Dali::TouchPoint > *result = 0 ;
49448
49449   arg1 = (int)jarg1;
49450   {
49451     try {
49452       try {
49453         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49454       }
49455       catch(std::out_of_range &_e) {
49456         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49457         return 0;
49458       }
49459
49460     } catch (std::out_of_range& e) {
49461       {
49462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49463       };
49464     } catch (std::exception& e) {
49465       {
49466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49467       };
49468     } catch (Dali::DaliException e) {
49469       {
49470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49471       };
49472     } catch (...) {
49473       {
49474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49475       };
49476     }
49477   }
49478
49479   jresult = (void *)result;
49480   return jresult;
49481 }
49482
49483
49484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49485   void * jresult ;
49486   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49487   int arg2 ;
49488   SwigValueWrapper< Dali::TouchPoint > result;
49489
49490   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49491   arg2 = (int)jarg2;
49492   {
49493     try {
49494       try {
49495         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49496       }
49497       catch(std::out_of_range &_e) {
49498         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49499         return 0;
49500       }
49501
49502     } catch (std::out_of_range& e) {
49503       {
49504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49505       };
49506     } catch (std::exception& e) {
49507       {
49508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49509       };
49510     } catch (Dali::DaliException e) {
49511       {
49512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49513       };
49514     } catch (...) {
49515       {
49516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49517       };
49518     }
49519   }
49520
49521   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49522   return jresult;
49523 }
49524
49525
49526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49527   void * jresult ;
49528   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49529   int arg2 ;
49530   Dali::TouchPoint *result = 0 ;
49531
49532   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49533   arg2 = (int)jarg2;
49534   {
49535     try {
49536       try {
49537         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49538       }
49539       catch(std::out_of_range &_e) {
49540         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49541         return 0;
49542       }
49543
49544     } catch (std::out_of_range& e) {
49545       {
49546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49547       };
49548     } catch (std::exception& e) {
49549       {
49550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49551       };
49552     } catch (Dali::DaliException e) {
49553       {
49554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49555       };
49556     } catch (...) {
49557       {
49558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49559       };
49560     }
49561   }
49562
49563   jresult = (void *)result;
49564   return jresult;
49565 }
49566
49567
49568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49569   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49570   int arg2 ;
49571   Dali::TouchPoint *arg3 = 0 ;
49572
49573   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49574   arg2 = (int)jarg2;
49575   arg3 = (Dali::TouchPoint *)jarg3;
49576   if (!arg3) {
49577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49578     return ;
49579   }
49580   {
49581     try {
49582       try {
49583         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49584       }
49585       catch(std::out_of_range &_e) {
49586         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49587         return ;
49588       }
49589
49590     } catch (std::out_of_range& e) {
49591       {
49592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49593       };
49594     } catch (std::exception& e) {
49595       {
49596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49597       };
49598     } catch (Dali::DaliException e) {
49599       {
49600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49601       };
49602     } catch (...) {
49603       {
49604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49605       };
49606     }
49607   }
49608
49609 }
49610
49611
49612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49613   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49614   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49615
49616   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49617   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49618   if (!arg2) {
49619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49620     return ;
49621   }
49622   {
49623     try {
49624       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49625     } catch (std::out_of_range& e) {
49626       {
49627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49628       };
49629     } catch (std::exception& e) {
49630       {
49631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49632       };
49633     } catch (Dali::DaliException e) {
49634       {
49635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49636       };
49637     } catch (...) {
49638       {
49639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49640       };
49641     }
49642   }
49643
49644 }
49645
49646
49647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49648   void * jresult ;
49649   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49650   int arg2 ;
49651   int arg3 ;
49652   std::vector< Dali::TouchPoint > *result = 0 ;
49653
49654   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49655   arg2 = (int)jarg2;
49656   arg3 = (int)jarg3;
49657   {
49658     try {
49659       try {
49660         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49661       }
49662       catch(std::out_of_range &_e) {
49663         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49664         return 0;
49665       }
49666       catch(std::invalid_argument &_e) {
49667         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49668         return 0;
49669       }
49670
49671     } catch (std::out_of_range& e) {
49672       {
49673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49674       };
49675     } catch (std::exception& e) {
49676       {
49677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49678       };
49679     } catch (Dali::DaliException e) {
49680       {
49681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49682       };
49683     } catch (...) {
49684       {
49685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49686       };
49687     }
49688   }
49689
49690   jresult = (void *)result;
49691   return jresult;
49692 }
49693
49694
49695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49696   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49697   int arg2 ;
49698   Dali::TouchPoint *arg3 = 0 ;
49699
49700   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49701   arg2 = (int)jarg2;
49702   arg3 = (Dali::TouchPoint *)jarg3;
49703   if (!arg3) {
49704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49705     return ;
49706   }
49707   {
49708     try {
49709       try {
49710         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49711       }
49712       catch(std::out_of_range &_e) {
49713         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49714         return ;
49715       }
49716
49717     } catch (std::out_of_range& e) {
49718       {
49719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49720       };
49721     } catch (std::exception& e) {
49722       {
49723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49724       };
49725     } catch (Dali::DaliException e) {
49726       {
49727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49728       };
49729     } catch (...) {
49730       {
49731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49732       };
49733     }
49734   }
49735
49736 }
49737
49738
49739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49740   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49741   int arg2 ;
49742   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49743
49744   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49745   arg2 = (int)jarg2;
49746   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49747   if (!arg3) {
49748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49749     return ;
49750   }
49751   {
49752     try {
49753       try {
49754         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49755       }
49756       catch(std::out_of_range &_e) {
49757         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49758         return ;
49759       }
49760
49761     } catch (std::out_of_range& e) {
49762       {
49763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49764       };
49765     } catch (std::exception& e) {
49766       {
49767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49768       };
49769     } catch (Dali::DaliException e) {
49770       {
49771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49772       };
49773     } catch (...) {
49774       {
49775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49776       };
49777     }
49778   }
49779
49780 }
49781
49782
49783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49784   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49785   int arg2 ;
49786
49787   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49788   arg2 = (int)jarg2;
49789   {
49790     try {
49791       try {
49792         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49793       }
49794       catch(std::out_of_range &_e) {
49795         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49796         return ;
49797       }
49798
49799     } catch (std::out_of_range& e) {
49800       {
49801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49802       };
49803     } catch (std::exception& e) {
49804       {
49805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49806       };
49807     } catch (Dali::DaliException e) {
49808       {
49809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49810       };
49811     } catch (...) {
49812       {
49813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49814       };
49815     }
49816   }
49817
49818 }
49819
49820
49821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49822   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49823   int arg2 ;
49824   int arg3 ;
49825
49826   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49827   arg2 = (int)jarg2;
49828   arg3 = (int)jarg3;
49829   {
49830     try {
49831       try {
49832         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49833       }
49834       catch(std::out_of_range &_e) {
49835         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49836         return ;
49837       }
49838       catch(std::invalid_argument &_e) {
49839         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49840         return ;
49841       }
49842
49843     } catch (std::out_of_range& e) {
49844       {
49845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49846       };
49847     } catch (std::exception& e) {
49848       {
49849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49850       };
49851     } catch (Dali::DaliException e) {
49852       {
49853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49854       };
49855     } catch (...) {
49856       {
49857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49858       };
49859     }
49860   }
49861
49862 }
49863
49864
49865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49866   void * jresult ;
49867   Dali::TouchPoint *arg1 = 0 ;
49868   int arg2 ;
49869   std::vector< Dali::TouchPoint > *result = 0 ;
49870
49871   arg1 = (Dali::TouchPoint *)jarg1;
49872   if (!arg1) {
49873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49874     return 0;
49875   }
49876   arg2 = (int)jarg2;
49877   {
49878     try {
49879       try {
49880         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49881       }
49882       catch(std::out_of_range &_e) {
49883         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49884         return 0;
49885       }
49886
49887     } catch (std::out_of_range& e) {
49888       {
49889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49890       };
49891     } catch (std::exception& e) {
49892       {
49893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49894       };
49895     } catch (Dali::DaliException e) {
49896       {
49897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49898       };
49899     } catch (...) {
49900       {
49901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49902       };
49903     }
49904   }
49905
49906   jresult = (void *)result;
49907   return jresult;
49908 }
49909
49910
49911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49912   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49913
49914   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49915   {
49916     try {
49917       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49918     } catch (std::out_of_range& e) {
49919       {
49920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49921       };
49922     } catch (std::exception& e) {
49923       {
49924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49925       };
49926     } catch (Dali::DaliException e) {
49927       {
49928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49929       };
49930     } catch (...) {
49931       {
49932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49933       };
49934     }
49935   }
49936
49937 }
49938
49939
49940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49941   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49942   int arg2 ;
49943   int arg3 ;
49944
49945   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49946   arg2 = (int)jarg2;
49947   arg3 = (int)jarg3;
49948   {
49949     try {
49950       try {
49951         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49952       }
49953       catch(std::out_of_range &_e) {
49954         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49955         return ;
49956       }
49957       catch(std::invalid_argument &_e) {
49958         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49959         return ;
49960       }
49961
49962     } catch (std::out_of_range& e) {
49963       {
49964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49965       };
49966     } catch (std::exception& e) {
49967       {
49968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49969       };
49970     } catch (Dali::DaliException e) {
49971       {
49972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49973       };
49974     } catch (...) {
49975       {
49976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49977       };
49978     }
49979   }
49980
49981 }
49982
49983
49984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49985   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49986   int arg2 ;
49987   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49988
49989   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49990   arg2 = (int)jarg2;
49991   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49992   if (!arg3) {
49993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49994     return ;
49995   }
49996   {
49997     try {
49998       try {
49999         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
50000       }
50001       catch(std::out_of_range &_e) {
50002         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50003         return ;
50004       }
50005
50006     } catch (std::out_of_range& e) {
50007       {
50008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50009       };
50010     } catch (std::exception& e) {
50011       {
50012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50013       };
50014     } catch (Dali::DaliException e) {
50015       {
50016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50017       };
50018     } catch (...) {
50019       {
50020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50021       };
50022     }
50023   }
50024
50025 }
50026
50027
50028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50029   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50030
50031   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50032   {
50033     try {
50034       delete arg1;
50035     } catch (std::out_of_range& e) {
50036       {
50037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50038       };
50039     } catch (std::exception& e) {
50040       {
50041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50042       };
50043     } catch (Dali::DaliException e) {
50044       {
50045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50046       };
50047     } catch (...) {
50048       {
50049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50050       };
50051     }
50052   }
50053
50054 }
50055
50056
50057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50058   void * jresult ;
50059   Dali::Rect< int > *result = 0 ;
50060
50061   {
50062     try {
50063       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50064     } catch (std::out_of_range& e) {
50065       {
50066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50067       };
50068     } catch (std::exception& e) {
50069       {
50070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50071       };
50072     } catch (Dali::DaliException e) {
50073       {
50074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50075       };
50076     } catch (...) {
50077       {
50078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50079       };
50080     }
50081   }
50082
50083   jresult = (void *)result;
50084   return jresult;
50085 }
50086
50087
50088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50089   void * jresult ;
50090   int arg1 ;
50091   int arg2 ;
50092   int arg3 ;
50093   int arg4 ;
50094   Dali::Rect< int > *result = 0 ;
50095
50096   arg1 = (int)jarg1;
50097   arg2 = (int)jarg2;
50098   arg3 = (int)jarg3;
50099   arg4 = (int)jarg4;
50100   {
50101     try {
50102       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50103     } catch (std::out_of_range& e) {
50104       {
50105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50106       };
50107     } catch (std::exception& e) {
50108       {
50109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50110       };
50111     } catch (Dali::DaliException e) {
50112       {
50113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50114       };
50115     } catch (...) {
50116       {
50117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50118       };
50119     }
50120   }
50121
50122   jresult = (void *)result;
50123   return jresult;
50124 }
50125
50126
50127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50128   void * jresult ;
50129   Dali::Rect< int > *arg1 = 0 ;
50130   Dali::Rect< int > *result = 0 ;
50131
50132   arg1 = (Dali::Rect< int > *)jarg1;
50133   if (!arg1) {
50134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50135     return 0;
50136   }
50137   {
50138     try {
50139       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50140     } catch (std::out_of_range& e) {
50141       {
50142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50143       };
50144     } catch (std::exception& e) {
50145       {
50146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50147       };
50148     } catch (Dali::DaliException e) {
50149       {
50150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50151       };
50152     } catch (...) {
50153       {
50154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50155       };
50156     }
50157   }
50158
50159   jresult = (void *)result;
50160   return jresult;
50161 }
50162
50163
50164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50165   void * jresult ;
50166   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50167   Dali::Rect< int > *arg2 = 0 ;
50168   Dali::Rect< int > *result = 0 ;
50169
50170   arg1 = (Dali::Rect< int > *)jarg1;
50171   arg2 = (Dali::Rect< int > *)jarg2;
50172   if (!arg2) {
50173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50174     return 0;
50175   }
50176   {
50177     try {
50178       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50179     } catch (std::out_of_range& e) {
50180       {
50181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50182       };
50183     } catch (std::exception& e) {
50184       {
50185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50186       };
50187     } catch (Dali::DaliException e) {
50188       {
50189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50190       };
50191     } catch (...) {
50192       {
50193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50194       };
50195     }
50196   }
50197
50198   jresult = (void *)result;
50199   return jresult;
50200 }
50201
50202
50203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50204   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50205   int arg2 ;
50206   int arg3 ;
50207   int arg4 ;
50208   int arg5 ;
50209
50210   arg1 = (Dali::Rect< int > *)jarg1;
50211   arg2 = (int)jarg2;
50212   arg3 = (int)jarg3;
50213   arg4 = (int)jarg4;
50214   arg5 = (int)jarg5;
50215   {
50216     try {
50217       (arg1)->Set(arg2,arg3,arg4,arg5);
50218     } catch (std::out_of_range& e) {
50219       {
50220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50221       };
50222     } catch (std::exception& e) {
50223       {
50224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50225       };
50226     } catch (Dali::DaliException e) {
50227       {
50228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50229       };
50230     } catch (...) {
50231       {
50232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50233       };
50234     }
50235   }
50236
50237 }
50238
50239
50240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50241   unsigned int jresult ;
50242   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50243   bool result;
50244
50245   arg1 = (Dali::Rect< int > *)jarg1;
50246   {
50247     try {
50248       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50249     } catch (std::out_of_range& e) {
50250       {
50251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50252       };
50253     } catch (std::exception& e) {
50254       {
50255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50256       };
50257     } catch (Dali::DaliException e) {
50258       {
50259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50260       };
50261     } catch (...) {
50262       {
50263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50264       };
50265     }
50266   }
50267
50268   jresult = result;
50269   return jresult;
50270 }
50271
50272
50273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50274   int jresult ;
50275   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50276   int result;
50277
50278   arg1 = (Dali::Rect< int > *)jarg1;
50279   {
50280     try {
50281       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50282     } catch (std::out_of_range& e) {
50283       {
50284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50285       };
50286     } catch (std::exception& e) {
50287       {
50288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50289       };
50290     } catch (Dali::DaliException e) {
50291       {
50292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50293       };
50294     } catch (...) {
50295       {
50296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50297       };
50298     }
50299   }
50300
50301   jresult = result;
50302   return jresult;
50303 }
50304
50305
50306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50307   int jresult ;
50308   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50309   int result;
50310
50311   arg1 = (Dali::Rect< int > *)jarg1;
50312   {
50313     try {
50314       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50315     } catch (std::out_of_range& e) {
50316       {
50317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50318       };
50319     } catch (std::exception& e) {
50320       {
50321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50322       };
50323     } catch (Dali::DaliException e) {
50324       {
50325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50326       };
50327     } catch (...) {
50328       {
50329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50330       };
50331     }
50332   }
50333
50334   jresult = result;
50335   return jresult;
50336 }
50337
50338
50339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50340   int jresult ;
50341   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50342   int result;
50343
50344   arg1 = (Dali::Rect< int > *)jarg1;
50345   {
50346     try {
50347       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50348     } catch (std::out_of_range& e) {
50349       {
50350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50351       };
50352     } catch (std::exception& e) {
50353       {
50354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50355       };
50356     } catch (Dali::DaliException e) {
50357       {
50358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50359       };
50360     } catch (...) {
50361       {
50362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50363       };
50364     }
50365   }
50366
50367   jresult = result;
50368   return jresult;
50369 }
50370
50371
50372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50373   int jresult ;
50374   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50375   int result;
50376
50377   arg1 = (Dali::Rect< int > *)jarg1;
50378   {
50379     try {
50380       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50381     } catch (std::out_of_range& e) {
50382       {
50383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50384       };
50385     } catch (std::exception& e) {
50386       {
50387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50388       };
50389     } catch (Dali::DaliException e) {
50390       {
50391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50392       };
50393     } catch (...) {
50394       {
50395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50396       };
50397     }
50398   }
50399
50400   jresult = result;
50401   return jresult;
50402 }
50403
50404
50405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50406   int jresult ;
50407   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50408   int result;
50409
50410   arg1 = (Dali::Rect< int > *)jarg1;
50411   {
50412     try {
50413       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50414     } catch (std::out_of_range& e) {
50415       {
50416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50417       };
50418     } catch (std::exception& e) {
50419       {
50420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50421       };
50422     } catch (Dali::DaliException e) {
50423       {
50424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50425       };
50426     } catch (...) {
50427       {
50428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50429       };
50430     }
50431   }
50432
50433   jresult = result;
50434   return jresult;
50435 }
50436
50437
50438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50439   unsigned int jresult ;
50440   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50441   Dali::Rect< int > *arg2 = 0 ;
50442   bool result;
50443
50444   arg1 = (Dali::Rect< int > *)jarg1;
50445   arg2 = (Dali::Rect< int > *)jarg2;
50446   if (!arg2) {
50447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50448     return 0;
50449   }
50450   {
50451     try {
50452       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50453     } catch (std::out_of_range& e) {
50454       {
50455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50456       };
50457     } catch (std::exception& e) {
50458       {
50459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50460       };
50461     } catch (Dali::DaliException e) {
50462       {
50463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50464       };
50465     } catch (...) {
50466       {
50467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50468       };
50469     }
50470   }
50471
50472   jresult = result;
50473   return jresult;
50474 }
50475
50476
50477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50478   unsigned int jresult ;
50479   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50480   Dali::Rect< int > *arg2 = 0 ;
50481   bool result;
50482
50483   arg1 = (Dali::Rect< int > *)jarg1;
50484   arg2 = (Dali::Rect< int > *)jarg2;
50485   if (!arg2) {
50486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50487     return 0;
50488   }
50489   {
50490     try {
50491       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50492     } catch (std::out_of_range& e) {
50493       {
50494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50495       };
50496     } catch (std::exception& e) {
50497       {
50498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50499       };
50500     } catch (Dali::DaliException e) {
50501       {
50502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50503       };
50504     } catch (...) {
50505       {
50506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50507       };
50508     }
50509   }
50510
50511   jresult = result;
50512   return jresult;
50513 }
50514
50515
50516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50517   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50518   int arg2 ;
50519
50520   arg1 = (Dali::Rect< int > *)jarg1;
50521   arg2 = (int)jarg2;
50522   if (arg1) (arg1)->x = arg2;
50523 }
50524
50525
50526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50527   int jresult ;
50528   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50529   int result;
50530
50531   arg1 = (Dali::Rect< int > *)jarg1;
50532   result = (int) ((arg1)->x);
50533   jresult = result;
50534   return jresult;
50535 }
50536
50537
50538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50539   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50540   int arg2 ;
50541
50542   arg1 = (Dali::Rect< int > *)jarg1;
50543   arg2 = (int)jarg2;
50544   if (arg1) (arg1)->left = arg2;
50545 }
50546
50547
50548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50549   int jresult ;
50550   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50551   int result;
50552
50553   arg1 = (Dali::Rect< int > *)jarg1;
50554   result = (int) ((arg1)->left);
50555   jresult = result;
50556   return jresult;
50557 }
50558
50559
50560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50561   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50562   int arg2 ;
50563
50564   arg1 = (Dali::Rect< int > *)jarg1;
50565   arg2 = (int)jarg2;
50566   if (arg1) (arg1)->y = arg2;
50567 }
50568
50569
50570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50571   int jresult ;
50572   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50573   int result;
50574
50575   arg1 = (Dali::Rect< int > *)jarg1;
50576   result = (int) ((arg1)->y);
50577   jresult = result;
50578   return jresult;
50579 }
50580
50581
50582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50583   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50584   int arg2 ;
50585
50586   arg1 = (Dali::Rect< int > *)jarg1;
50587   arg2 = (int)jarg2;
50588   if (arg1) (arg1)->right = arg2;
50589 }
50590
50591
50592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50593   int jresult ;
50594   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50595   int result;
50596
50597   arg1 = (Dali::Rect< int > *)jarg1;
50598   result = (int) ((arg1)->right);
50599   jresult = result;
50600   return jresult;
50601 }
50602
50603
50604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50605   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50606   int arg2 ;
50607
50608   arg1 = (Dali::Rect< int > *)jarg1;
50609   arg2 = (int)jarg2;
50610   if (arg1) (arg1)->width = arg2;
50611 }
50612
50613
50614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50615   int jresult ;
50616   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50617   int result;
50618
50619   arg1 = (Dali::Rect< int > *)jarg1;
50620   result = (int) ((arg1)->width);
50621   jresult = result;
50622   return jresult;
50623 }
50624
50625
50626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50627   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50628   int arg2 ;
50629
50630   arg1 = (Dali::Rect< int > *)jarg1;
50631   arg2 = (int)jarg2;
50632   if (arg1) (arg1)->bottom = arg2;
50633 }
50634
50635
50636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50637   int jresult ;
50638   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50639   int result;
50640
50641   arg1 = (Dali::Rect< int > *)jarg1;
50642   result = (int) ((arg1)->bottom);
50643   jresult = result;
50644   return jresult;
50645 }
50646
50647
50648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50649   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50650   int arg2 ;
50651
50652   arg1 = (Dali::Rect< int > *)jarg1;
50653   arg2 = (int)jarg2;
50654   if (arg1) (arg1)->height = arg2;
50655 }
50656
50657
50658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50659   int jresult ;
50660   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50661   int result;
50662
50663   arg1 = (Dali::Rect< int > *)jarg1;
50664   result = (int) ((arg1)->height);
50665   jresult = result;
50666   return jresult;
50667 }
50668
50669
50670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50671   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50672   int arg2 ;
50673
50674   arg1 = (Dali::Rect< int > *)jarg1;
50675   arg2 = (int)jarg2;
50676   if (arg1) (arg1)->top = arg2;
50677 }
50678
50679
50680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50681   int jresult ;
50682   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50683   int result;
50684
50685   arg1 = (Dali::Rect< int > *)jarg1;
50686   result = (int) ((arg1)->top);
50687   jresult = result;
50688   return jresult;
50689 }
50690
50691
50692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50693   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50694
50695   arg1 = (Dali::Rect< int > *)jarg1;
50696   {
50697     try {
50698       delete arg1;
50699     } catch (std::out_of_range& e) {
50700       {
50701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50702       };
50703     } catch (std::exception& e) {
50704       {
50705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50706       };
50707     } catch (Dali::DaliException e) {
50708       {
50709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50710       };
50711     } catch (...) {
50712       {
50713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50714       };
50715     }
50716   }
50717
50718 }
50719
50720
50721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50722   void * jresult ;
50723   Dali::Rect< float > *result = 0 ;
50724
50725   {
50726     try {
50727       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50728     } catch (std::out_of_range& e) {
50729       {
50730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50731       };
50732     } catch (std::exception& e) {
50733       {
50734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50735       };
50736     } catch (Dali::DaliException e) {
50737       {
50738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50739       };
50740     } catch (...) {
50741       {
50742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50743       };
50744     }
50745   }
50746
50747   jresult = (void *)result;
50748   return jresult;
50749 }
50750
50751
50752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50753   void * jresult ;
50754   float arg1 ;
50755   float arg2 ;
50756   float arg3 ;
50757   float arg4 ;
50758   Dali::Rect< float > *result = 0 ;
50759
50760   arg1 = (float)jarg1;
50761   arg2 = (float)jarg2;
50762   arg3 = (float)jarg4;
50763   arg4 = (float)jarg3;
50764   {
50765     try {
50766       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50767     } catch (std::out_of_range& e) {
50768       {
50769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50770       };
50771     } catch (std::exception& e) {
50772       {
50773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50774       };
50775     } catch (Dali::DaliException e) {
50776       {
50777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50778       };
50779     } catch (...) {
50780       {
50781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50782       };
50783     }
50784   }
50785
50786   jresult = (void *)result;
50787   return jresult;
50788 }
50789
50790
50791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50792   void * jresult ;
50793   Dali::Rect< float > *arg1 = 0 ;
50794   Dali::Rect< float > *result = 0 ;
50795
50796   arg1 = (Dali::Rect< float > *)jarg1;
50797   if (!arg1) {
50798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50799     return 0;
50800   }
50801   {
50802     try {
50803       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50804     } catch (std::out_of_range& e) {
50805       {
50806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50807       };
50808     } catch (std::exception& e) {
50809       {
50810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50811       };
50812     } catch (Dali::DaliException e) {
50813       {
50814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50815       };
50816     } catch (...) {
50817       {
50818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50819       };
50820     }
50821   }
50822
50823   jresult = (void *)result;
50824   return jresult;
50825 }
50826
50827
50828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50829   void * jresult ;
50830   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50831   Dali::Rect< float > *arg2 = 0 ;
50832   Dali::Rect< float > *result = 0 ;
50833
50834   arg1 = (Dali::Rect< float > *)jarg1;
50835   arg2 = (Dali::Rect< float > *)jarg2;
50836   if (!arg2) {
50837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50838     return 0;
50839   }
50840   {
50841     try {
50842       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50843     } catch (std::out_of_range& e) {
50844       {
50845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50846       };
50847     } catch (std::exception& e) {
50848       {
50849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50850       };
50851     } catch (Dali::DaliException e) {
50852       {
50853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50854       };
50855     } catch (...) {
50856       {
50857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50858       };
50859     }
50860   }
50861
50862   jresult = (void *)result;
50863   return jresult;
50864 }
50865
50866
50867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50868   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50869   float arg2 ;
50870   float arg3 ;
50871   float arg4 ;
50872   float arg5 ;
50873
50874   arg1 = (Dali::Rect< float > *)jarg1;
50875   arg2 = (float)jarg2;
50876   arg3 = (float)jarg3;
50877   arg4 = (float)jarg5;
50878   arg5 = (float)jarg4;
50879   {
50880     try {
50881       (arg1)->Set(arg2,arg3,arg4,arg5);
50882     } catch (std::out_of_range& e) {
50883       {
50884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50885       };
50886     } catch (std::exception& e) {
50887       {
50888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50889       };
50890     } catch (Dali::DaliException e) {
50891       {
50892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50893       };
50894     } catch (...) {
50895       {
50896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50897       };
50898     }
50899   }
50900
50901 }
50902
50903
50904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50905   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50906   float arg2 ;
50907
50908   arg1 = (Dali::Rect< float > *)jarg1;
50909   arg2 = (float)jarg2;
50910   if (arg1) (arg1)->left = arg2;
50911 }
50912
50913
50914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50915   float jresult ;
50916   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50917   float result;
50918
50919   arg1 = (Dali::Rect< float > *)jarg1;
50920   result = (float) ((arg1)->left);
50921   jresult = result;
50922   return jresult;
50923 }
50924
50925
50926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50927   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50928   float arg2 ;
50929
50930   arg1 = (Dali::Rect< float > *)jarg1;
50931   arg2 = (float)jarg2;
50932   if (arg1) (arg1)->left = arg2;
50933 }
50934
50935
50936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50937   float jresult ;
50938   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50939   float result;
50940
50941   arg1 = (Dali::Rect< float > *)jarg1;
50942   result = (float) ((arg1)->left);
50943   jresult = result;
50944   return jresult;
50945 }
50946
50947
50948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50949   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50950   float arg2 ;
50951
50952   arg1 = (Dali::Rect< float > *)jarg1;
50953   arg2 = (float)jarg2;
50954   if (arg1) (arg1)->right = arg2;
50955 }
50956
50957
50958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50959   float jresult ;
50960   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50961   float result;
50962
50963   arg1 = (Dali::Rect< float > *)jarg1;
50964   result = (float) ((arg1)->right);
50965   jresult = result;
50966   return jresult;
50967 }
50968
50969
50970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50971   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50972   float arg2 ;
50973
50974   arg1 = (Dali::Rect< float > *)jarg1;
50975   arg2 = (float)jarg2;
50976   if (arg1) (arg1)->right = arg2;
50977 }
50978
50979
50980 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50981   float jresult ;
50982   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50983   float result;
50984
50985   arg1 = (Dali::Rect< float > *)jarg1;
50986   result = (float) ((arg1)->right);
50987   jresult = result;
50988   return jresult;
50989 }
50990
50991
50992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50993   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50994   float arg2 ;
50995
50996   arg1 = (Dali::Rect< float > *)jarg1;
50997   arg2 = (float)jarg2;
50998   if (arg1) (arg1)->bottom = arg2;
50999 }
51000
51001
51002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51003   float jresult ;
51004   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51005   float result;
51006
51007   arg1 = (Dali::Rect< float > *)jarg1;
51008   result = (float) ((arg1)->bottom);
51009   jresult = result;
51010   return jresult;
51011 }
51012
51013
51014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51015   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51016   float arg2 ;
51017
51018   arg1 = (Dali::Rect< float > *)jarg1;
51019   arg2 = (float)jarg2;
51020   if (arg1) (arg1)->top = arg2;
51021 }
51022
51023
51024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51025   float jresult ;
51026   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51027   float result;
51028
51029   arg1 = (Dali::Rect< float > *)jarg1;
51030   result = (float) ((arg1)->top);
51031   jresult = result;
51032   return jresult;
51033 }
51034
51035
51036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51037   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51038
51039   arg1 = (Dali::Rect< float > *)jarg1;
51040   {
51041     try {
51042       delete arg1;
51043     } catch (std::out_of_range& e) {
51044       {
51045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51046       };
51047     } catch (std::exception& e) {
51048       {
51049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51050       };
51051     } catch (Dali::DaliException e) {
51052       {
51053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51054       };
51055     } catch (...) {
51056       {
51057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51058       };
51059     }
51060   }
51061
51062 }
51063
51064
51065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51066   int jresult ;
51067   int result;
51068
51069   result = (int)Dali::Vector< int >::BaseType;
51070   jresult = (int)result;
51071   return jresult;
51072 }
51073
51074
51075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51076   void * jresult ;
51077   Dali::Vector< int > *result = 0 ;
51078
51079   {
51080     try {
51081       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51082     } catch (std::out_of_range& e) {
51083       {
51084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51085       };
51086     } catch (std::exception& e) {
51087       {
51088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51089       };
51090     } catch (Dali::DaliException e) {
51091       {
51092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51093       };
51094     } catch (...) {
51095       {
51096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51097       };
51098     }
51099   }
51100
51101   jresult = (void *)result;
51102   return jresult;
51103 }
51104
51105
51106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51107   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51108
51109   arg1 = (Dali::Vector< int > *)jarg1;
51110   {
51111     try {
51112       delete arg1;
51113     } catch (std::out_of_range& e) {
51114       {
51115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51116       };
51117     } catch (std::exception& e) {
51118       {
51119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51120       };
51121     } catch (Dali::DaliException e) {
51122       {
51123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51124       };
51125     } catch (...) {
51126       {
51127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51128       };
51129     }
51130   }
51131
51132 }
51133
51134
51135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51136   void * jresult ;
51137   Dali::Vector< int > *arg1 = 0 ;
51138   Dali::Vector< int > *result = 0 ;
51139
51140   arg1 = (Dali::Vector< int > *)jarg1;
51141   if (!arg1) {
51142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51143     return 0;
51144   }
51145   {
51146     try {
51147       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51148     } catch (std::out_of_range& e) {
51149       {
51150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51151       };
51152     } catch (std::exception& e) {
51153       {
51154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51155       };
51156     } catch (Dali::DaliException e) {
51157       {
51158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51159       };
51160     } catch (...) {
51161       {
51162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51163       };
51164     }
51165   }
51166
51167   jresult = (void *)result;
51168   return jresult;
51169 }
51170
51171
51172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51173   void * jresult ;
51174   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51175   Dali::Vector< int > *arg2 = 0 ;
51176   Dali::Vector< int > *result = 0 ;
51177
51178   arg1 = (Dali::Vector< int > *)jarg1;
51179   arg2 = (Dali::Vector< int > *)jarg2;
51180   if (!arg2) {
51181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51182     return 0;
51183   }
51184   {
51185     try {
51186       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51187     } catch (std::out_of_range& e) {
51188       {
51189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51190       };
51191     } catch (std::exception& e) {
51192       {
51193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51194       };
51195     } catch (Dali::DaliException e) {
51196       {
51197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51198       };
51199     } catch (...) {
51200       {
51201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51202       };
51203     }
51204   }
51205
51206   jresult = (void *)result;
51207   return jresult;
51208 }
51209
51210
51211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51212   void * jresult ;
51213   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51214   Dali::Vector< int >::Iterator result;
51215
51216   arg1 = (Dali::Vector< int > *)jarg1;
51217   {
51218     try {
51219       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51220     } catch (std::out_of_range& e) {
51221       {
51222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51223       };
51224     } catch (std::exception& e) {
51225       {
51226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51227       };
51228     } catch (Dali::DaliException e) {
51229       {
51230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51231       };
51232     } catch (...) {
51233       {
51234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51235       };
51236     }
51237   }
51238
51239   jresult = (void *)result;
51240   return jresult;
51241 }
51242
51243
51244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51245   void * jresult ;
51246   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51247   Dali::Vector< int >::Iterator result;
51248
51249   arg1 = (Dali::Vector< int > *)jarg1;
51250   {
51251     try {
51252       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51253     } catch (std::out_of_range& e) {
51254       {
51255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51256       };
51257     } catch (std::exception& e) {
51258       {
51259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51260       };
51261     } catch (Dali::DaliException e) {
51262       {
51263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51264       };
51265     } catch (...) {
51266       {
51267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51268       };
51269     }
51270   }
51271
51272   jresult = (void *)result;
51273   return jresult;
51274 }
51275
51276
51277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51278   void * jresult ;
51279   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51280   Dali::Vector< int >::SizeType arg2 ;
51281   Dali::Vector< int >::ItemType *result = 0 ;
51282
51283   arg1 = (Dali::Vector< int > *)jarg1;
51284   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51285   {
51286     try {
51287       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51288     } catch (std::out_of_range& e) {
51289       {
51290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51291       };
51292     } catch (std::exception& e) {
51293       {
51294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51295       };
51296     } catch (Dali::DaliException e) {
51297       {
51298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51299       };
51300     } catch (...) {
51301       {
51302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51303       };
51304     }
51305   }
51306
51307   jresult = (void *)result;
51308   return jresult;
51309 }
51310
51311
51312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51313   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51314   Dali::Vector< int >::ItemType *arg2 = 0 ;
51315   Dali::Vector< int >::ItemType temp2 ;
51316
51317   arg1 = (Dali::Vector< int > *)jarg1;
51318   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51319   arg2 = &temp2;
51320   {
51321     try {
51322       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51323     } catch (std::out_of_range& e) {
51324       {
51325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51326       };
51327     } catch (std::exception& e) {
51328       {
51329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51330       };
51331     } catch (Dali::DaliException e) {
51332       {
51333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51334       };
51335     } catch (...) {
51336       {
51337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51338       };
51339     }
51340   }
51341
51342 }
51343
51344
51345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51346   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51347   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51348   Dali::Vector< int >::ItemType *arg3 = 0 ;
51349   Dali::Vector< int >::ItemType temp3 ;
51350
51351   arg1 = (Dali::Vector< int > *)jarg1;
51352   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51353   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51354   arg3 = &temp3;
51355   {
51356     try {
51357       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51358     } catch (std::out_of_range& e) {
51359       {
51360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51361       };
51362     } catch (std::exception& e) {
51363       {
51364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51365       };
51366     } catch (Dali::DaliException e) {
51367       {
51368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51369       };
51370     } catch (...) {
51371       {
51372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51373       };
51374     }
51375   }
51376
51377 }
51378
51379
51380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51381   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51382   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51383   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51384   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51385
51386   arg1 = (Dali::Vector< int > *)jarg1;
51387   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51388   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51389   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51390   {
51391     try {
51392       (arg1)->Insert(arg2,arg3,arg4);
51393     } catch (std::out_of_range& e) {
51394       {
51395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51396       };
51397     } catch (std::exception& e) {
51398       {
51399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51400       };
51401     } catch (Dali::DaliException e) {
51402       {
51403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51404       };
51405     } catch (...) {
51406       {
51407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51408       };
51409     }
51410   }
51411
51412 }
51413
51414
51415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51416   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51417   Dali::Vector< int >::SizeType arg2 ;
51418
51419   arg1 = (Dali::Vector< int > *)jarg1;
51420   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51421   {
51422     try {
51423       (arg1)->Reserve(arg2);
51424     } catch (std::out_of_range& e) {
51425       {
51426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51427       };
51428     } catch (std::exception& e) {
51429       {
51430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51431       };
51432     } catch (Dali::DaliException e) {
51433       {
51434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51435       };
51436     } catch (...) {
51437       {
51438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51439       };
51440     }
51441   }
51442
51443 }
51444
51445
51446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51447   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51448   Dali::Vector< int >::SizeType arg2 ;
51449
51450   arg1 = (Dali::Vector< int > *)jarg1;
51451   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51452   {
51453     try {
51454       (arg1)->Resize(arg2);
51455     } catch (std::out_of_range& e) {
51456       {
51457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51458       };
51459     } catch (std::exception& e) {
51460       {
51461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51462       };
51463     } catch (Dali::DaliException e) {
51464       {
51465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51466       };
51467     } catch (...) {
51468       {
51469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51470       };
51471     }
51472   }
51473
51474 }
51475
51476
51477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51478   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51479   Dali::Vector< int >::SizeType arg2 ;
51480   Dali::Vector< int >::ItemType *arg3 = 0 ;
51481   Dali::Vector< int >::ItemType temp3 ;
51482
51483   arg1 = (Dali::Vector< int > *)jarg1;
51484   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51485   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51486   arg3 = &temp3;
51487   {
51488     try {
51489       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51490     } catch (std::out_of_range& e) {
51491       {
51492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51493       };
51494     } catch (std::exception& e) {
51495       {
51496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51497       };
51498     } catch (Dali::DaliException e) {
51499       {
51500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51501       };
51502     } catch (...) {
51503       {
51504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51505       };
51506     }
51507   }
51508
51509 }
51510
51511
51512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51513   void * jresult ;
51514   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51515   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51516   Dali::Vector< int >::Iterator result;
51517
51518   arg1 = (Dali::Vector< int > *)jarg1;
51519   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51520   {
51521     try {
51522       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51523     } catch (std::out_of_range& e) {
51524       {
51525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51526       };
51527     } catch (std::exception& e) {
51528       {
51529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51530       };
51531     } catch (Dali::DaliException e) {
51532       {
51533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51534       };
51535     } catch (...) {
51536       {
51537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51538       };
51539     }
51540   }
51541
51542   jresult = (void *)result;
51543   return jresult;
51544 }
51545
51546
51547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51548   void * jresult ;
51549   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51550   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51551   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51552   Dali::Vector< int >::Iterator result;
51553
51554   arg1 = (Dali::Vector< int > *)jarg1;
51555   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51556   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51557   {
51558     try {
51559       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51560     } catch (std::out_of_range& e) {
51561       {
51562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51563       };
51564     } catch (std::exception& e) {
51565       {
51566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51567       };
51568     } catch (Dali::DaliException e) {
51569       {
51570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51571       };
51572     } catch (...) {
51573       {
51574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51575       };
51576     }
51577   }
51578
51579   jresult = (void *)result;
51580   return jresult;
51581 }
51582
51583
51584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51585   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51586   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51587
51588   arg1 = (Dali::Vector< int > *)jarg1;
51589   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51590   {
51591     try {
51592       (arg1)->Remove(arg2);
51593     } catch (std::out_of_range& e) {
51594       {
51595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51596       };
51597     } catch (std::exception& e) {
51598       {
51599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51600       };
51601     } catch (Dali::DaliException e) {
51602       {
51603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51604       };
51605     } catch (...) {
51606       {
51607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51608       };
51609     }
51610   }
51611
51612 }
51613
51614
51615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51616   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51617   Dali::Vector< int > *arg2 = 0 ;
51618
51619   arg1 = (Dali::Vector< int > *)jarg1;
51620   arg2 = (Dali::Vector< int > *)jarg2;
51621   if (!arg2) {
51622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51623     return ;
51624   }
51625   {
51626     try {
51627       (arg1)->Swap(*arg2);
51628     } catch (std::out_of_range& e) {
51629       {
51630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51631       };
51632     } catch (std::exception& e) {
51633       {
51634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51635       };
51636     } catch (Dali::DaliException e) {
51637       {
51638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51639       };
51640     } catch (...) {
51641       {
51642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51643       };
51644     }
51645   }
51646
51647 }
51648
51649
51650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51651   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51652
51653   arg1 = (Dali::Vector< int > *)jarg1;
51654   {
51655     try {
51656       (arg1)->Clear();
51657     } catch (std::out_of_range& e) {
51658       {
51659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51660       };
51661     } catch (std::exception& e) {
51662       {
51663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51664       };
51665     } catch (Dali::DaliException e) {
51666       {
51667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51668       };
51669     } catch (...) {
51670       {
51671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51672       };
51673     }
51674   }
51675
51676 }
51677
51678
51679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51680   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51681
51682   arg1 = (Dali::Vector< int > *)jarg1;
51683   {
51684     try {
51685       (arg1)->Release();
51686     } catch (std::out_of_range& e) {
51687       {
51688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51689       };
51690     } catch (std::exception& e) {
51691       {
51692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51693       };
51694     } catch (Dali::DaliException e) {
51695       {
51696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51697       };
51698     } catch (...) {
51699       {
51700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51701       };
51702     }
51703   }
51704
51705 }
51706
51707
51708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51709   int jresult ;
51710   int result;
51711
51712   result = (int)Dali::Vector< float >::BaseType;
51713   jresult = (int)result;
51714   return jresult;
51715 }
51716
51717
51718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51719   void * jresult ;
51720   Dali::Vector< float > *result = 0 ;
51721
51722   {
51723     try {
51724       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51725     } catch (std::out_of_range& e) {
51726       {
51727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51728       };
51729     } catch (std::exception& e) {
51730       {
51731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51732       };
51733     } catch (Dali::DaliException e) {
51734       {
51735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51736       };
51737     } catch (...) {
51738       {
51739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51740       };
51741     }
51742   }
51743
51744   jresult = (void *)result;
51745   return jresult;
51746 }
51747
51748
51749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51750   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51751
51752   arg1 = (Dali::Vector< float > *)jarg1;
51753   {
51754     try {
51755       delete arg1;
51756     } catch (std::out_of_range& e) {
51757       {
51758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51759       };
51760     } catch (std::exception& e) {
51761       {
51762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51763       };
51764     } catch (Dali::DaliException e) {
51765       {
51766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51767       };
51768     } catch (...) {
51769       {
51770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51771       };
51772     }
51773   }
51774
51775 }
51776
51777
51778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51779   void * jresult ;
51780   Dali::Vector< float > *arg1 = 0 ;
51781   Dali::Vector< float > *result = 0 ;
51782
51783   arg1 = (Dali::Vector< float > *)jarg1;
51784   if (!arg1) {
51785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51786     return 0;
51787   }
51788   {
51789     try {
51790       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51791     } catch (std::out_of_range& e) {
51792       {
51793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51794       };
51795     } catch (std::exception& e) {
51796       {
51797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51798       };
51799     } catch (Dali::DaliException e) {
51800       {
51801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51802       };
51803     } catch (...) {
51804       {
51805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51806       };
51807     }
51808   }
51809
51810   jresult = (void *)result;
51811   return jresult;
51812 }
51813
51814
51815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51816   void * jresult ;
51817   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51818   Dali::Vector< float > *arg2 = 0 ;
51819   Dali::Vector< float > *result = 0 ;
51820
51821   arg1 = (Dali::Vector< float > *)jarg1;
51822   arg2 = (Dali::Vector< float > *)jarg2;
51823   if (!arg2) {
51824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51825     return 0;
51826   }
51827   {
51828     try {
51829       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51830     } catch (std::out_of_range& e) {
51831       {
51832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51833       };
51834     } catch (std::exception& e) {
51835       {
51836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51837       };
51838     } catch (Dali::DaliException e) {
51839       {
51840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51841       };
51842     } catch (...) {
51843       {
51844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51845       };
51846     }
51847   }
51848
51849   jresult = (void *)result;
51850   return jresult;
51851 }
51852
51853
51854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51855   void * jresult ;
51856   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51857   Dali::Vector< float >::Iterator result;
51858
51859   arg1 = (Dali::Vector< float > *)jarg1;
51860   {
51861     try {
51862       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51863     } catch (std::out_of_range& e) {
51864       {
51865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51866       };
51867     } catch (std::exception& e) {
51868       {
51869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51870       };
51871     } catch (Dali::DaliException e) {
51872       {
51873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51874       };
51875     } catch (...) {
51876       {
51877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51878       };
51879     }
51880   }
51881
51882   jresult = (void *)result;
51883   return jresult;
51884 }
51885
51886
51887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51888   void * jresult ;
51889   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51890   Dali::Vector< float >::Iterator result;
51891
51892   arg1 = (Dali::Vector< float > *)jarg1;
51893   {
51894     try {
51895       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51896     } catch (std::out_of_range& e) {
51897       {
51898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51899       };
51900     } catch (std::exception& e) {
51901       {
51902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51903       };
51904     } catch (Dali::DaliException e) {
51905       {
51906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51907       };
51908     } catch (...) {
51909       {
51910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51911       };
51912     }
51913   }
51914
51915   jresult = (void *)result;
51916   return jresult;
51917 }
51918
51919
51920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51921   void * jresult ;
51922   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51923   Dali::Vector< float >::SizeType arg2 ;
51924   Dali::Vector< float >::ItemType *result = 0 ;
51925
51926   arg1 = (Dali::Vector< float > *)jarg1;
51927   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51928   {
51929     try {
51930       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51931     } catch (std::out_of_range& e) {
51932       {
51933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51934       };
51935     } catch (std::exception& e) {
51936       {
51937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51938       };
51939     } catch (Dali::DaliException e) {
51940       {
51941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51942       };
51943     } catch (...) {
51944       {
51945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51946       };
51947     }
51948   }
51949
51950   jresult = (void *)result;
51951   return jresult;
51952 }
51953
51954
51955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51956   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51957   Dali::Vector< float >::ItemType *arg2 = 0 ;
51958   Dali::Vector< float >::ItemType temp2 ;
51959
51960   arg1 = (Dali::Vector< float > *)jarg1;
51961   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51962   arg2 = &temp2;
51963   {
51964     try {
51965       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51966     } catch (std::out_of_range& e) {
51967       {
51968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51969       };
51970     } catch (std::exception& e) {
51971       {
51972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51973       };
51974     } catch (Dali::DaliException e) {
51975       {
51976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51977       };
51978     } catch (...) {
51979       {
51980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51981       };
51982     }
51983   }
51984
51985 }
51986
51987
51988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51989   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51990   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51991   Dali::Vector< float >::ItemType *arg3 = 0 ;
51992   Dali::Vector< float >::ItemType temp3 ;
51993
51994   arg1 = (Dali::Vector< float > *)jarg1;
51995   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51996   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51997   arg3 = &temp3;
51998   {
51999     try {
52000       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52001     } catch (std::out_of_range& e) {
52002       {
52003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52004       };
52005     } catch (std::exception& e) {
52006       {
52007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52008       };
52009     } catch (Dali::DaliException e) {
52010       {
52011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52012       };
52013     } catch (...) {
52014       {
52015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52016       };
52017     }
52018   }
52019
52020 }
52021
52022
52023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52024   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52025   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52026   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52027   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52028
52029   arg1 = (Dali::Vector< float > *)jarg1;
52030   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52031   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52032   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52033   {
52034     try {
52035       (arg1)->Insert(arg2,arg3,arg4);
52036     } catch (std::out_of_range& e) {
52037       {
52038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52039       };
52040     } catch (std::exception& e) {
52041       {
52042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52043       };
52044     } catch (Dali::DaliException e) {
52045       {
52046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52047       };
52048     } catch (...) {
52049       {
52050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52051       };
52052     }
52053   }
52054
52055 }
52056
52057
52058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52059   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52060   Dali::Vector< float >::SizeType arg2 ;
52061
52062   arg1 = (Dali::Vector< float > *)jarg1;
52063   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52064   {
52065     try {
52066       (arg1)->Reserve(arg2);
52067     } catch (std::out_of_range& e) {
52068       {
52069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52070       };
52071     } catch (std::exception& e) {
52072       {
52073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52074       };
52075     } catch (Dali::DaliException e) {
52076       {
52077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52078       };
52079     } catch (...) {
52080       {
52081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52082       };
52083     }
52084   }
52085
52086 }
52087
52088 //// ========================= end of part 2 =============================
52089
52090 //// ========================== start part 3 ===============================
52091
52092
52093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52094   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52095   Dali::Vector< float >::SizeType arg2 ;
52096
52097   arg1 = (Dali::Vector< float > *)jarg1;
52098   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52099   {
52100     try {
52101       (arg1)->Resize(arg2);
52102     } catch (std::out_of_range& e) {
52103       {
52104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52105       };
52106     } catch (std::exception& e) {
52107       {
52108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52109       };
52110     } catch (Dali::DaliException e) {
52111       {
52112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52113       };
52114     } catch (...) {
52115       {
52116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52117       };
52118     }
52119   }
52120
52121 }
52122
52123
52124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52125   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52126   Dali::Vector< float >::SizeType arg2 ;
52127   Dali::Vector< float >::ItemType *arg3 = 0 ;
52128   Dali::Vector< float >::ItemType temp3 ;
52129
52130   arg1 = (Dali::Vector< float > *)jarg1;
52131   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52132   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52133   arg3 = &temp3;
52134   {
52135     try {
52136       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52137     } catch (std::out_of_range& e) {
52138       {
52139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52140       };
52141     } catch (std::exception& e) {
52142       {
52143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52144       };
52145     } catch (Dali::DaliException e) {
52146       {
52147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52148       };
52149     } catch (...) {
52150       {
52151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52152       };
52153     }
52154   }
52155
52156 }
52157
52158
52159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52160   void * jresult ;
52161   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52162   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52163   Dali::Vector< float >::Iterator result;
52164
52165   arg1 = (Dali::Vector< float > *)jarg1;
52166   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52167   {
52168     try {
52169       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52170     } catch (std::out_of_range& e) {
52171       {
52172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52173       };
52174     } catch (std::exception& e) {
52175       {
52176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52177       };
52178     } catch (Dali::DaliException e) {
52179       {
52180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52181       };
52182     } catch (...) {
52183       {
52184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52185       };
52186     }
52187   }
52188
52189   jresult = (void *)result;
52190   return jresult;
52191 }
52192
52193
52194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52195   void * jresult ;
52196   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52197   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52198   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52199   Dali::Vector< float >::Iterator result;
52200
52201   arg1 = (Dali::Vector< float > *)jarg1;
52202   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52203   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52204   {
52205     try {
52206       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52207     } catch (std::out_of_range& e) {
52208       {
52209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52210       };
52211     } catch (std::exception& e) {
52212       {
52213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52214       };
52215     } catch (Dali::DaliException e) {
52216       {
52217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52218       };
52219     } catch (...) {
52220       {
52221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52222       };
52223     }
52224   }
52225
52226   jresult = (void *)result;
52227   return jresult;
52228 }
52229
52230
52231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52232   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52233   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52234
52235   arg1 = (Dali::Vector< float > *)jarg1;
52236   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52237   {
52238     try {
52239       (arg1)->Remove(arg2);
52240     } catch (std::out_of_range& e) {
52241       {
52242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52243       };
52244     } catch (std::exception& e) {
52245       {
52246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52247       };
52248     } catch (Dali::DaliException e) {
52249       {
52250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52251       };
52252     } catch (...) {
52253       {
52254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52255       };
52256     }
52257   }
52258
52259 }
52260
52261
52262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52263   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52264   Dali::Vector< float > *arg2 = 0 ;
52265
52266   arg1 = (Dali::Vector< float > *)jarg1;
52267   arg2 = (Dali::Vector< float > *)jarg2;
52268   if (!arg2) {
52269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52270     return ;
52271   }
52272   {
52273     try {
52274       (arg1)->Swap(*arg2);
52275     } catch (std::out_of_range& e) {
52276       {
52277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52278       };
52279     } catch (std::exception& e) {
52280       {
52281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52282       };
52283     } catch (Dali::DaliException e) {
52284       {
52285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52286       };
52287     } catch (...) {
52288       {
52289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52290       };
52291     }
52292   }
52293
52294 }
52295
52296
52297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52298   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52299
52300   arg1 = (Dali::Vector< float > *)jarg1;
52301   {
52302     try {
52303       (arg1)->Clear();
52304     } catch (std::out_of_range& e) {
52305       {
52306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52307       };
52308     } catch (std::exception& e) {
52309       {
52310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52311       };
52312     } catch (Dali::DaliException e) {
52313       {
52314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52315       };
52316     } catch (...) {
52317       {
52318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52319       };
52320     }
52321   }
52322
52323 }
52324
52325
52326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52327   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52328
52329   arg1 = (Dali::Vector< float > *)jarg1;
52330   {
52331     try {
52332       (arg1)->Release();
52333     } catch (std::out_of_range& e) {
52334       {
52335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52336       };
52337     } catch (std::exception& e) {
52338       {
52339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52340       };
52341     } catch (Dali::DaliException e) {
52342       {
52343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52344       };
52345     } catch (...) {
52346       {
52347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52348       };
52349     }
52350   }
52351
52352 }
52353
52354
52355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52356   int jresult ;
52357   int result;
52358
52359   result = (int)Dali::Vector< unsigned char >::BaseType;
52360   jresult = (int)result;
52361   return jresult;
52362 }
52363
52364
52365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52366   void * jresult ;
52367   Dali::Vector< unsigned char > *result = 0 ;
52368
52369   {
52370     try {
52371       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52372     } catch (std::out_of_range& e) {
52373       {
52374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52375       };
52376     } catch (std::exception& e) {
52377       {
52378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52379       };
52380     } catch (Dali::DaliException e) {
52381       {
52382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52383       };
52384     } catch (...) {
52385       {
52386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52387       };
52388     }
52389   }
52390
52391   jresult = (void *)result;
52392   return jresult;
52393 }
52394
52395
52396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52397   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52398
52399   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52400   {
52401     try {
52402       delete arg1;
52403     } catch (std::out_of_range& e) {
52404       {
52405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52406       };
52407     } catch (std::exception& e) {
52408       {
52409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52410       };
52411     } catch (Dali::DaliException e) {
52412       {
52413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52414       };
52415     } catch (...) {
52416       {
52417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52418       };
52419     }
52420   }
52421
52422 }
52423
52424
52425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52426   void * jresult ;
52427   Dali::Vector< unsigned char > *arg1 = 0 ;
52428   Dali::Vector< unsigned char > *result = 0 ;
52429
52430   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52431   if (!arg1) {
52432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52433     return 0;
52434   }
52435   {
52436     try {
52437       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52438     } catch (std::out_of_range& e) {
52439       {
52440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52441       };
52442     } catch (std::exception& e) {
52443       {
52444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52445       };
52446     } catch (Dali::DaliException e) {
52447       {
52448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52449       };
52450     } catch (...) {
52451       {
52452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52453       };
52454     }
52455   }
52456
52457   jresult = (void *)result;
52458   return jresult;
52459 }
52460
52461
52462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52463   void * jresult ;
52464   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52465   Dali::Vector< unsigned char > *arg2 = 0 ;
52466   Dali::Vector< unsigned char > *result = 0 ;
52467
52468   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52469   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52470   if (!arg2) {
52471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52472     return 0;
52473   }
52474   {
52475     try {
52476       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52477     } catch (std::out_of_range& e) {
52478       {
52479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52480       };
52481     } catch (std::exception& e) {
52482       {
52483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52484       };
52485     } catch (Dali::DaliException e) {
52486       {
52487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52488       };
52489     } catch (...) {
52490       {
52491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52492       };
52493     }
52494   }
52495
52496   jresult = (void *)result;
52497   return jresult;
52498 }
52499
52500
52501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52502   void * jresult ;
52503   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52504   Dali::Vector< unsigned char >::Iterator result;
52505
52506   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52507   {
52508     try {
52509       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52510     } catch (std::out_of_range& e) {
52511       {
52512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52513       };
52514     } catch (std::exception& e) {
52515       {
52516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52517       };
52518     } catch (Dali::DaliException e) {
52519       {
52520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52521       };
52522     } catch (...) {
52523       {
52524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52525       };
52526     }
52527   }
52528
52529   jresult = (void *)result;
52530   return jresult;
52531 }
52532
52533
52534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52535   void * jresult ;
52536   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52537   Dali::Vector< unsigned char >::Iterator result;
52538
52539   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52540   {
52541     try {
52542       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52543     } catch (std::out_of_range& e) {
52544       {
52545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52546       };
52547     } catch (std::exception& e) {
52548       {
52549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52550       };
52551     } catch (Dali::DaliException e) {
52552       {
52553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52554       };
52555     } catch (...) {
52556       {
52557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52558       };
52559     }
52560   }
52561
52562   jresult = (void *)result;
52563   return jresult;
52564 }
52565
52566
52567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52568   void * jresult ;
52569   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52570   Dali::Vector< unsigned char >::SizeType arg2 ;
52571   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52572
52573   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52574   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52575   {
52576     try {
52577       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52578     } catch (std::out_of_range& e) {
52579       {
52580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52581       };
52582     } catch (std::exception& e) {
52583       {
52584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52585       };
52586     } catch (Dali::DaliException e) {
52587       {
52588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52589       };
52590     } catch (...) {
52591       {
52592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52593       };
52594     }
52595   }
52596
52597   jresult = (void *)result;
52598   return jresult;
52599 }
52600
52601
52602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52603   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52604   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52605   Dali::Vector< unsigned char >::ItemType temp2 ;
52606
52607   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52608   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52609   arg2 = &temp2;
52610   {
52611     try {
52612       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52613     } catch (std::out_of_range& e) {
52614       {
52615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52616       };
52617     } catch (std::exception& e) {
52618       {
52619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52620       };
52621     } catch (Dali::DaliException e) {
52622       {
52623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52624       };
52625     } catch (...) {
52626       {
52627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52628       };
52629     }
52630   }
52631
52632 }
52633
52634
52635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52636   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52637   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52638   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52639   Dali::Vector< unsigned char >::ItemType temp3 ;
52640
52641   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52642   arg2 = jarg2;
52643   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52644   arg3 = &temp3;
52645   {
52646     try {
52647       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52648     } catch (std::out_of_range& e) {
52649       {
52650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52651       };
52652     } catch (std::exception& e) {
52653       {
52654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52655       };
52656     } catch (Dali::DaliException e) {
52657       {
52658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52659       };
52660     } catch (...) {
52661       {
52662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52663       };
52664     }
52665   }
52666
52667
52668
52669 }
52670
52671
52672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52673   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52674   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52675   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52676   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52677
52678   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52679   arg2 = jarg2;
52680   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52681   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52682   {
52683     try {
52684       (arg1)->Insert(arg2,arg3,arg4);
52685     } catch (std::out_of_range& e) {
52686       {
52687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52688       };
52689     } catch (std::exception& e) {
52690       {
52691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52692       };
52693     } catch (Dali::DaliException e) {
52694       {
52695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52696       };
52697     } catch (...) {
52698       {
52699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52700       };
52701     }
52702   }
52703
52704
52705
52706 }
52707
52708
52709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52710   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52711   Dali::Vector< unsigned char >::SizeType arg2 ;
52712
52713   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52714   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52715   {
52716     try {
52717       (arg1)->Reserve(arg2);
52718     } catch (std::out_of_range& e) {
52719       {
52720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52721       };
52722     } catch (std::exception& e) {
52723       {
52724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52725       };
52726     } catch (Dali::DaliException e) {
52727       {
52728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52729       };
52730     } catch (...) {
52731       {
52732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52733       };
52734     }
52735   }
52736
52737 }
52738
52739
52740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52741   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52742   Dali::Vector< unsigned char >::SizeType arg2 ;
52743
52744   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52745   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52746   {
52747     try {
52748       (arg1)->Resize(arg2);
52749     } catch (std::out_of_range& e) {
52750       {
52751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52752       };
52753     } catch (std::exception& e) {
52754       {
52755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52756       };
52757     } catch (Dali::DaliException e) {
52758       {
52759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52760       };
52761     } catch (...) {
52762       {
52763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52764       };
52765     }
52766   }
52767
52768 }
52769
52770
52771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52772   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52773   Dali::Vector< unsigned char >::SizeType arg2 ;
52774   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52775   Dali::Vector< unsigned char >::ItemType temp3 ;
52776
52777   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52778   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52779   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52780   arg3 = &temp3;
52781   {
52782     try {
52783       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52784     } catch (std::out_of_range& e) {
52785       {
52786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52787       };
52788     } catch (std::exception& e) {
52789       {
52790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52791       };
52792     } catch (Dali::DaliException e) {
52793       {
52794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52795       };
52796     } catch (...) {
52797       {
52798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52799       };
52800     }
52801   }
52802
52803 }
52804
52805
52806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52807   void * jresult ;
52808   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52809   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52810   Dali::Vector< unsigned char >::Iterator result;
52811
52812   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52813   arg2 = jarg2;
52814   {
52815     try {
52816       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52817     } catch (std::out_of_range& e) {
52818       {
52819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52820       };
52821     } catch (std::exception& e) {
52822       {
52823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52824       };
52825     } catch (Dali::DaliException e) {
52826       {
52827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52828       };
52829     } catch (...) {
52830       {
52831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52832       };
52833     }
52834   }
52835
52836   jresult = (void *)result;
52837
52838
52839   return jresult;
52840 }
52841
52842
52843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52844   void * jresult ;
52845   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52846   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52847   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52848   Dali::Vector< unsigned char >::Iterator result;
52849
52850   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52851   arg2 = jarg2;
52852   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52853   {
52854     try {
52855       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52856     } catch (std::out_of_range& e) {
52857       {
52858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52859       };
52860     } catch (std::exception& e) {
52861       {
52862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52863       };
52864     } catch (Dali::DaliException e) {
52865       {
52866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52867       };
52868     } catch (...) {
52869       {
52870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52871       };
52872     }
52873   }
52874
52875   jresult = (void *)result;
52876
52877
52878   return jresult;
52879 }
52880
52881
52882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52883   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52884   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52885
52886   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52887   arg2 = jarg2;
52888   {
52889     try {
52890       (arg1)->Remove(arg2);
52891     } catch (std::out_of_range& e) {
52892       {
52893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52894       };
52895     } catch (std::exception& e) {
52896       {
52897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52898       };
52899     } catch (Dali::DaliException e) {
52900       {
52901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52902       };
52903     } catch (...) {
52904       {
52905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52906       };
52907     }
52908   }
52909
52910
52911
52912 }
52913
52914
52915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52916   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52917   Dali::Vector< unsigned char > *arg2 = 0 ;
52918
52919   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52920   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52921   if (!arg2) {
52922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52923     return ;
52924   }
52925   {
52926     try {
52927       (arg1)->Swap(*arg2);
52928     } catch (std::out_of_range& e) {
52929       {
52930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52931       };
52932     } catch (std::exception& e) {
52933       {
52934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52935       };
52936     } catch (Dali::DaliException e) {
52937       {
52938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52939       };
52940     } catch (...) {
52941       {
52942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52943       };
52944     }
52945   }
52946
52947 }
52948
52949
52950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52951   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52952
52953   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52954   {
52955     try {
52956       (arg1)->Clear();
52957     } catch (std::out_of_range& e) {
52958       {
52959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52960       };
52961     } catch (std::exception& e) {
52962       {
52963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52964       };
52965     } catch (Dali::DaliException e) {
52966       {
52967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52968       };
52969     } catch (...) {
52970       {
52971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52972       };
52973     }
52974   }
52975
52976 }
52977
52978
52979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52980   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52981
52982   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52983   {
52984     try {
52985       (arg1)->Release();
52986     } catch (std::out_of_range& e) {
52987       {
52988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52989       };
52990     } catch (std::exception& e) {
52991       {
52992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52993       };
52994     } catch (Dali::DaliException e) {
52995       {
52996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52997       };
52998     } catch (...) {
52999       {
53000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53001       };
53002     }
53003   }
53004
53005 }
53006
53007
53008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53009   int jresult ;
53010   int result;
53011
53012   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53013   jresult = (int)result;
53014   return jresult;
53015 }
53016
53017
53018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53019   void * jresult ;
53020   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53021
53022   {
53023     try {
53024       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53025     } catch (std::out_of_range& e) {
53026       {
53027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53028       };
53029     } catch (std::exception& e) {
53030       {
53031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53032       };
53033     } catch (Dali::DaliException e) {
53034       {
53035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53036       };
53037     } catch (...) {
53038       {
53039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53040       };
53041     }
53042   }
53043
53044   jresult = (void *)result;
53045   return jresult;
53046 }
53047
53048
53049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53050   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53051
53052   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53053   {
53054     try {
53055       delete arg1;
53056     } catch (std::out_of_range& e) {
53057       {
53058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53059       };
53060     } catch (std::exception& e) {
53061       {
53062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53063       };
53064     } catch (Dali::DaliException e) {
53065       {
53066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53067       };
53068     } catch (...) {
53069       {
53070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53071       };
53072     }
53073   }
53074
53075 }
53076
53077
53078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53079   void * jresult ;
53080   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53081   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53082
53083   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53084   if (!arg1) {
53085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53086     return 0;
53087   }
53088   {
53089     try {
53090       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53091     } catch (std::out_of_range& e) {
53092       {
53093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53094       };
53095     } catch (std::exception& e) {
53096       {
53097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53098       };
53099     } catch (Dali::DaliException e) {
53100       {
53101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53102       };
53103     } catch (...) {
53104       {
53105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53106       };
53107     }
53108   }
53109
53110   jresult = (void *)result;
53111   return jresult;
53112 }
53113
53114
53115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53116   void * jresult ;
53117   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53118   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53119   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53120
53121   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53122   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53123   if (!arg2) {
53124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53125     return 0;
53126   }
53127   {
53128     try {
53129       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53130     } catch (std::out_of_range& e) {
53131       {
53132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53133       };
53134     } catch (std::exception& e) {
53135       {
53136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53137       };
53138     } catch (Dali::DaliException e) {
53139       {
53140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53141       };
53142     } catch (...) {
53143       {
53144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53145       };
53146     }
53147   }
53148
53149   jresult = (void *)result;
53150   return jresult;
53151 }
53152
53153
53154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53155   void * jresult ;
53156   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53157   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53158
53159   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53160   {
53161     try {
53162       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53163     } catch (std::out_of_range& e) {
53164       {
53165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53166       };
53167     } catch (std::exception& e) {
53168       {
53169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53170       };
53171     } catch (Dali::DaliException e) {
53172       {
53173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53174       };
53175     } catch (...) {
53176       {
53177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53178       };
53179     }
53180   }
53181
53182   jresult = (void *)result;
53183   return jresult;
53184 }
53185
53186
53187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53188   void * jresult ;
53189   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53190   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53191
53192   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53193   {
53194     try {
53195       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53196     } catch (std::out_of_range& e) {
53197       {
53198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53199       };
53200     } catch (std::exception& e) {
53201       {
53202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53203       };
53204     } catch (Dali::DaliException e) {
53205       {
53206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53207       };
53208     } catch (...) {
53209       {
53210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53211       };
53212     }
53213   }
53214
53215   jresult = (void *)result;
53216   return jresult;
53217 }
53218
53219
53220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53221   void * jresult ;
53222   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53223   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53224   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53225
53226   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53227   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53228   {
53229     try {
53230       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53231     } catch (std::out_of_range& e) {
53232       {
53233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53234       };
53235     } catch (std::exception& e) {
53236       {
53237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53238       };
53239     } catch (Dali::DaliException e) {
53240       {
53241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53242       };
53243     } catch (...) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53246       };
53247     }
53248   }
53249
53250   jresult = (void *)result;
53251   return jresult;
53252 }
53253
53254
53255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53256   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53257   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53258
53259   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53260   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53261   if (!arg2) {
53262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53263     return ;
53264   }
53265   {
53266     try {
53267       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53268     } catch (std::out_of_range& e) {
53269       {
53270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53271       };
53272     } catch (std::exception& e) {
53273       {
53274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53275       };
53276     } catch (Dali::DaliException e) {
53277       {
53278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53279       };
53280     } catch (...) {
53281       {
53282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53283       };
53284     }
53285   }
53286
53287 }
53288
53289
53290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53291   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53292   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53293   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53294
53295   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53296   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53297   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53298   if (!arg3) {
53299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53300     return ;
53301   }
53302   {
53303     try {
53304       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53305     } catch (std::out_of_range& e) {
53306       {
53307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53308       };
53309     } catch (std::exception& e) {
53310       {
53311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53312       };
53313     } catch (Dali::DaliException e) {
53314       {
53315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53316       };
53317     } catch (...) {
53318       {
53319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53320       };
53321     }
53322   }
53323
53324 }
53325
53326
53327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53328   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53329   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53330   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53331   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53332
53333   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53334   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53335   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53336   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53337   {
53338     try {
53339       (arg1)->Insert(arg2,arg3,arg4);
53340     } catch (std::out_of_range& e) {
53341       {
53342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53343       };
53344     } catch (std::exception& e) {
53345       {
53346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53347       };
53348     } catch (Dali::DaliException e) {
53349       {
53350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53351       };
53352     } catch (...) {
53353       {
53354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53355       };
53356     }
53357   }
53358
53359 }
53360
53361
53362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53363   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53364   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53365
53366   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53367   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53368   {
53369     try {
53370       (arg1)->Reserve(arg2);
53371     } catch (std::out_of_range& e) {
53372       {
53373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53374       };
53375     } catch (std::exception& e) {
53376       {
53377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53378       };
53379     } catch (Dali::DaliException e) {
53380       {
53381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53382       };
53383     } catch (...) {
53384       {
53385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53386       };
53387     }
53388   }
53389
53390 }
53391
53392
53393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53394   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53395   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53396
53397   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53398   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53399   {
53400     try {
53401       (arg1)->Resize(arg2);
53402     } catch (std::out_of_range& e) {
53403       {
53404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53405       };
53406     } catch (std::exception& e) {
53407       {
53408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53409       };
53410     } catch (Dali::DaliException e) {
53411       {
53412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53413       };
53414     } catch (...) {
53415       {
53416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53417       };
53418     }
53419   }
53420
53421 }
53422
53423
53424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53425   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53426   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53427   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53428
53429   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53430   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53431   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53432   if (!arg3) {
53433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53434     return ;
53435   }
53436   {
53437     try {
53438       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53439     } catch (std::out_of_range& e) {
53440       {
53441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53442       };
53443     } catch (std::exception& e) {
53444       {
53445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53446       };
53447     } catch (Dali::DaliException e) {
53448       {
53449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53450       };
53451     } catch (...) {
53452       {
53453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53454       };
53455     }
53456   }
53457
53458 }
53459
53460
53461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53462   void * jresult ;
53463   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53464   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53465   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53466
53467   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53468   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53469   {
53470     try {
53471       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53472     } catch (std::out_of_range& e) {
53473       {
53474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53475       };
53476     } catch (std::exception& e) {
53477       {
53478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53479       };
53480     } catch (Dali::DaliException e) {
53481       {
53482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53483       };
53484     } catch (...) {
53485       {
53486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53487       };
53488     }
53489   }
53490
53491   jresult = (void *)result;
53492   return jresult;
53493 }
53494
53495
53496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53497   void * jresult ;
53498   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53499   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53500   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53501   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53502
53503   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53504   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53505   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53506   {
53507     try {
53508       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53509     } catch (std::out_of_range& e) {
53510       {
53511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53512       };
53513     } catch (std::exception& e) {
53514       {
53515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53516       };
53517     } catch (Dali::DaliException e) {
53518       {
53519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53520       };
53521     } catch (...) {
53522       {
53523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53524       };
53525     }
53526   }
53527
53528   jresult = (void *)result;
53529   return jresult;
53530 }
53531
53532
53533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53534   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53535   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53536
53537   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53538   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53539   {
53540     try {
53541       (arg1)->Remove(arg2);
53542     } catch (std::out_of_range& e) {
53543       {
53544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53545       };
53546     } catch (std::exception& e) {
53547       {
53548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53549       };
53550     } catch (Dali::DaliException e) {
53551       {
53552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53553       };
53554     } catch (...) {
53555       {
53556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53557       };
53558     }
53559   }
53560
53561 }
53562
53563
53564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53565   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53566   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53567
53568   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53569   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53570   if (!arg2) {
53571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53572     return ;
53573   }
53574   {
53575     try {
53576       (arg1)->Swap(*arg2);
53577     } catch (std::out_of_range& e) {
53578       {
53579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53580       };
53581     } catch (std::exception& e) {
53582       {
53583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53584       };
53585     } catch (Dali::DaliException e) {
53586       {
53587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53588       };
53589     } catch (...) {
53590       {
53591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53592       };
53593     }
53594   }
53595
53596 }
53597
53598
53599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53600   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53601
53602   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53603   {
53604     try {
53605       (arg1)->Clear();
53606     } catch (std::out_of_range& e) {
53607       {
53608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53609       };
53610     } catch (std::exception& e) {
53611       {
53612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53613       };
53614     } catch (Dali::DaliException e) {
53615       {
53616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53617       };
53618     } catch (...) {
53619       {
53620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53621       };
53622     }
53623   }
53624
53625 }
53626
53627
53628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53629   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53630
53631   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53632   {
53633     try {
53634       (arg1)->Release();
53635     } catch (std::out_of_range& e) {
53636       {
53637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53638       };
53639     } catch (std::exception& e) {
53640       {
53641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53642       };
53643     } catch (Dali::DaliException e) {
53644       {
53645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53646       };
53647     } catch (...) {
53648       {
53649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53650       };
53651     }
53652   }
53653
53654 }
53655
53656
53657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53658   void * jresult ;
53659   Dali::Signal< void () > *result = 0 ;
53660
53661   {
53662     try {
53663       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53664     } catch (std::out_of_range& e) {
53665       {
53666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53667       };
53668     } catch (std::exception& e) {
53669       {
53670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53671       };
53672     } catch (Dali::DaliException e) {
53673       {
53674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53675       };
53676     } catch (...) {
53677       {
53678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53679       };
53680     }
53681   }
53682
53683   jresult = (void *)result;
53684   return jresult;
53685 }
53686
53687
53688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53689   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53690
53691   arg1 = (Dali::Signal< void () > *)jarg1;
53692   {
53693     try {
53694       delete arg1;
53695     } catch (std::out_of_range& e) {
53696       {
53697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53698       };
53699     } catch (std::exception& e) {
53700       {
53701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53702       };
53703     } catch (Dali::DaliException e) {
53704       {
53705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53706       };
53707     } catch (...) {
53708       {
53709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53710       };
53711     }
53712   }
53713
53714 }
53715
53716
53717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53718   unsigned int jresult ;
53719   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53720   bool result;
53721
53722   arg1 = (Dali::Signal< void () > *)jarg1;
53723   {
53724     try {
53725       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53726     } catch (std::out_of_range& e) {
53727       {
53728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53729       };
53730     } catch (std::exception& e) {
53731       {
53732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53733       };
53734     } catch (Dali::DaliException e) {
53735       {
53736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53737       };
53738     } catch (...) {
53739       {
53740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53741       };
53742     }
53743   }
53744
53745   jresult = result;
53746   return jresult;
53747 }
53748
53749
53750 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53751   unsigned long jresult ;
53752   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53753   std::size_t result;
53754
53755   arg1 = (Dali::Signal< void () > *)jarg1;
53756   {
53757     try {
53758       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53759     } catch (std::out_of_range& e) {
53760       {
53761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53762       };
53763     } catch (std::exception& e) {
53764       {
53765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53766       };
53767     } catch (Dali::DaliException e) {
53768       {
53769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53770       };
53771     } catch (...) {
53772       {
53773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53774       };
53775     }
53776   }
53777
53778   jresult = (unsigned long)result;
53779   return jresult;
53780 }
53781
53782
53783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53784   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53785   void (*arg2)() = (void (*)()) 0 ;
53786
53787   arg1 = (Dali::Signal< void () > *)jarg1;
53788   arg2 = (void (*)())jarg2;
53789   {
53790     try {
53791       (arg1)->Connect(arg2);
53792     } catch (std::out_of_range& e) {
53793       {
53794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53795       };
53796     } catch (std::exception& e) {
53797       {
53798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53799       };
53800     } catch (Dali::DaliException e) {
53801       {
53802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53803       };
53804     } catch (...) {
53805       {
53806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53807       };
53808     }
53809   }
53810
53811 }
53812
53813
53814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53815   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53816   void (*arg2)() = (void (*)()) 0 ;
53817
53818   arg1 = (Dali::Signal< void () > *)jarg1;
53819   arg2 = (void (*)())jarg2;
53820   {
53821     try {
53822       (arg1)->Disconnect(arg2);
53823     } catch (std::out_of_range& e) {
53824       {
53825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53826       };
53827     } catch (std::exception& e) {
53828       {
53829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53830       };
53831     } catch (Dali::DaliException e) {
53832       {
53833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53834       };
53835     } catch (...) {
53836       {
53837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53838       };
53839     }
53840   }
53841
53842 }
53843
53844
53845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53846   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53847   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53848   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53849
53850   arg1 = (Dali::Signal< void () > *)jarg1;
53851   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53852   arg3 = (Dali::FunctorDelegate *)jarg3;
53853   {
53854     try {
53855       (arg1)->Connect(arg2,arg3);
53856     } catch (std::out_of_range& e) {
53857       {
53858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53859       };
53860     } catch (std::exception& e) {
53861       {
53862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53863       };
53864     } catch (Dali::DaliException e) {
53865       {
53866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53867       };
53868     } catch (...) {
53869       {
53870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53871       };
53872     }
53873   }
53874
53875 }
53876
53877
53878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53879   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53880
53881   arg1 = (Dali::Signal< void () > *)jarg1;
53882   {
53883     try {
53884       (arg1)->Emit();
53885     } catch (std::out_of_range& e) {
53886       {
53887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53888       };
53889     } catch (std::exception& e) {
53890       {
53891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53892       };
53893     } catch (Dali::DaliException e) {
53894       {
53895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53896       };
53897     } catch (...) {
53898       {
53899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53900       };
53901     }
53902   }
53903
53904 }
53905
53906
53907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53908   unsigned int jresult ;
53909   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53910   bool result;
53911
53912   arg1 = (Dali::Signal< void (float) > *)jarg1;
53913   {
53914     try {
53915       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53916     } catch (std::out_of_range& e) {
53917       {
53918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53919       };
53920     } catch (std::exception& e) {
53921       {
53922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53923       };
53924     } catch (Dali::DaliException e) {
53925       {
53926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53927       };
53928     } catch (...) {
53929       {
53930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53931       };
53932     }
53933   }
53934
53935   jresult = result;
53936   return jresult;
53937 }
53938
53939
53940 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53941   unsigned long jresult ;
53942   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53943   std::size_t result;
53944
53945   arg1 = (Dali::Signal< void (float) > *)jarg1;
53946   {
53947     try {
53948       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53949     } catch (std::out_of_range& e) {
53950       {
53951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53952       };
53953     } catch (std::exception& e) {
53954       {
53955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53956       };
53957     } catch (Dali::DaliException e) {
53958       {
53959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53960       };
53961     } catch (...) {
53962       {
53963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53964       };
53965     }
53966   }
53967
53968   jresult = (unsigned long)result;
53969   return jresult;
53970 }
53971
53972
53973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53974   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53975   void (*arg2)(float) = (void (*)(float)) 0 ;
53976
53977   arg1 = (Dali::Signal< void (float) > *)jarg1;
53978   arg2 = (void (*)(float))jarg2;
53979   {
53980     try {
53981       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53982     } catch (std::out_of_range& e) {
53983       {
53984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53985       };
53986     } catch (std::exception& e) {
53987       {
53988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53989       };
53990     } catch (Dali::DaliException e) {
53991       {
53992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53993       };
53994     } catch (...) {
53995       {
53996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53997       };
53998     }
53999   }
54000
54001 }
54002
54003
54004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54005   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54006   void (*arg2)(float) = (void (*)(float)) 0 ;
54007
54008   arg1 = (Dali::Signal< void (float) > *)jarg1;
54009   arg2 = (void (*)(float))jarg2;
54010   {
54011     try {
54012       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54013     } catch (std::out_of_range& e) {
54014       {
54015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54016       };
54017     } catch (std::exception& e) {
54018       {
54019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54020       };
54021     } catch (Dali::DaliException e) {
54022       {
54023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54024       };
54025     } catch (...) {
54026       {
54027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54028       };
54029     }
54030   }
54031
54032 }
54033
54034
54035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54036   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54037   float arg2 ;
54038
54039   arg1 = (Dali::Signal< void (float) > *)jarg1;
54040   arg2 = (float)jarg2;
54041   {
54042     try {
54043       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54044     } catch (std::out_of_range& e) {
54045       {
54046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54047       };
54048     } catch (std::exception& e) {
54049       {
54050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54051       };
54052     } catch (Dali::DaliException e) {
54053       {
54054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54055       };
54056     } catch (...) {
54057       {
54058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54059       };
54060     }
54061   }
54062
54063 }
54064
54065
54066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54067   void * jresult ;
54068   Dali::Signal< void (float) > *result = 0 ;
54069
54070   {
54071     try {
54072       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54073     } catch (std::out_of_range& e) {
54074       {
54075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54076       };
54077     } catch (std::exception& e) {
54078       {
54079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54080       };
54081     } catch (Dali::DaliException e) {
54082       {
54083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54084       };
54085     } catch (...) {
54086       {
54087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54088       };
54089     }
54090   }
54091
54092   jresult = (void *)result;
54093   return jresult;
54094 }
54095
54096
54097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54098   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54099
54100   arg1 = (Dali::Signal< void (float) > *)jarg1;
54101   {
54102     try {
54103       delete arg1;
54104     } catch (std::out_of_range& e) {
54105       {
54106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54107       };
54108     } catch (std::exception& e) {
54109       {
54110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54111       };
54112     } catch (Dali::DaliException e) {
54113       {
54114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54115       };
54116     } catch (...) {
54117       {
54118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54119       };
54120     }
54121   }
54122
54123 }
54124
54125
54126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54127   unsigned int jresult ;
54128   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54129   bool result;
54130
54131   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54132   {
54133     try {
54134       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54135     } catch (std::out_of_range& e) {
54136       {
54137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54138       };
54139     } catch (std::exception& e) {
54140       {
54141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54142       };
54143     } catch (Dali::DaliException e) {
54144       {
54145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54146       };
54147     } catch (...) {
54148       {
54149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54150       };
54151     }
54152   }
54153
54154   jresult = result;
54155   return jresult;
54156 }
54157
54158
54159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54160   unsigned long jresult ;
54161   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54162   std::size_t result;
54163
54164   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54165   {
54166     try {
54167       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54168     } catch (std::out_of_range& e) {
54169       {
54170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54171       };
54172     } catch (std::exception& e) {
54173       {
54174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54175       };
54176     } catch (Dali::DaliException e) {
54177       {
54178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54179       };
54180     } catch (...) {
54181       {
54182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54183       };
54184     }
54185   }
54186
54187   jresult = (unsigned long)result;
54188   return jresult;
54189 }
54190
54191
54192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54193   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54194   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54195
54196   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54197   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54198   {
54199     try {
54200       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54201     } catch (std::out_of_range& e) {
54202       {
54203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54204       };
54205     } catch (std::exception& e) {
54206       {
54207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54208       };
54209     } catch (Dali::DaliException e) {
54210       {
54211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54212       };
54213     } catch (...) {
54214       {
54215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54216       };
54217     }
54218   }
54219
54220 }
54221
54222
54223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54224   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54225   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54226
54227   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54228   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54229   {
54230     try {
54231       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54232     } catch (std::out_of_range& e) {
54233       {
54234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54235       };
54236     } catch (std::exception& e) {
54237       {
54238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54239       };
54240     } catch (Dali::DaliException e) {
54241       {
54242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54243       };
54244     } catch (...) {
54245       {
54246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54247       };
54248     }
54249   }
54250
54251 }
54252
54253
54254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54255   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54256   Dali::BaseHandle arg2 ;
54257   Dali::BaseHandle *argp2 ;
54258
54259   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54260   argp2 = (Dali::BaseHandle *)jarg2;
54261   if (!argp2) {
54262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54263     return ;
54264   }
54265   arg2 = *argp2;
54266   {
54267     try {
54268       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54269     } catch (std::out_of_range& e) {
54270       {
54271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54272       };
54273     } catch (std::exception& e) {
54274       {
54275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54276       };
54277     } catch (Dali::DaliException e) {
54278       {
54279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54280       };
54281     } catch (...) {
54282       {
54283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54284       };
54285     }
54286   }
54287
54288 }
54289
54290
54291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54292   void * jresult ;
54293   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54294
54295   {
54296     try {
54297       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54298     } catch (std::out_of_range& e) {
54299       {
54300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54301       };
54302     } catch (std::exception& e) {
54303       {
54304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54305       };
54306     } catch (Dali::DaliException e) {
54307       {
54308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54309       };
54310     } catch (...) {
54311       {
54312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54313       };
54314     }
54315   }
54316
54317   jresult = (void *)result;
54318   return jresult;
54319 }
54320
54321
54322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54323   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54324
54325   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54326   {
54327     try {
54328       delete arg1;
54329     } catch (std::out_of_range& e) {
54330       {
54331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54332       };
54333     } catch (std::exception& e) {
54334       {
54335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54336       };
54337     } catch (Dali::DaliException e) {
54338       {
54339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54340       };
54341     } catch (...) {
54342       {
54343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54344       };
54345     }
54346   }
54347
54348 }
54349
54350
54351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54352   unsigned int jresult ;
54353   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54354   bool result;
54355
54356   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54357   {
54358     try {
54359       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54360     } catch (std::out_of_range& e) {
54361       {
54362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54363       };
54364     } catch (std::exception& e) {
54365       {
54366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54367       };
54368     } catch (Dali::DaliException e) {
54369       {
54370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54371       };
54372     } catch (...) {
54373       {
54374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54375       };
54376     }
54377   }
54378
54379   jresult = result;
54380   return jresult;
54381 }
54382
54383
54384 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54385   unsigned long jresult ;
54386   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54387   std::size_t result;
54388
54389   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54390   {
54391     try {
54392       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54393     } catch (std::out_of_range& e) {
54394       {
54395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54396       };
54397     } catch (std::exception& e) {
54398       {
54399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54400       };
54401     } catch (Dali::DaliException e) {
54402       {
54403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54404       };
54405     } catch (...) {
54406       {
54407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54408       };
54409     }
54410   }
54411
54412   jresult = (unsigned long)result;
54413   return jresult;
54414 }
54415
54416
54417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54418   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54419   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54420
54421   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54422   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54423   {
54424     try {
54425       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54426     } catch (std::out_of_range& e) {
54427       {
54428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54429       };
54430     } catch (std::exception& e) {
54431       {
54432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54433       };
54434     } catch (Dali::DaliException e) {
54435       {
54436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54437       };
54438     } catch (...) {
54439       {
54440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54441       };
54442     }
54443   }
54444
54445 }
54446
54447
54448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54449   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54450   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54451
54452   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54453   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54454   {
54455     try {
54456       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54457     } catch (std::out_of_range& e) {
54458       {
54459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54460       };
54461     } catch (std::exception& e) {
54462       {
54463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54464       };
54465     } catch (Dali::DaliException e) {
54466       {
54467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54468       };
54469     } catch (...) {
54470       {
54471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54472       };
54473     }
54474   }
54475
54476 }
54477
54478
54479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54480   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54481   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54482
54483   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54484   arg2 = (Dali::RefObject *)jarg2;
54485   {
54486     try {
54487       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54488     } catch (std::out_of_range& e) {
54489       {
54490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54491       };
54492     } catch (std::exception& e) {
54493       {
54494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54495       };
54496     } catch (Dali::DaliException e) {
54497       {
54498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54499       };
54500     } catch (...) {
54501       {
54502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54503       };
54504     }
54505   }
54506
54507 }
54508
54509
54510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54511   void * jresult ;
54512   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54513
54514   {
54515     try {
54516       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54517     } catch (std::out_of_range& e) {
54518       {
54519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54520       };
54521     } catch (std::exception& e) {
54522       {
54523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54524       };
54525     } catch (Dali::DaliException e) {
54526       {
54527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54528       };
54529     } catch (...) {
54530       {
54531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54532       };
54533     }
54534   }
54535
54536   jresult = (void *)result;
54537   return jresult;
54538 }
54539
54540
54541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54542   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54543
54544   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54545   {
54546     try {
54547       delete arg1;
54548     } catch (std::out_of_range& e) {
54549       {
54550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54551       };
54552     } catch (std::exception& e) {
54553       {
54554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54555       };
54556     } catch (Dali::DaliException e) {
54557       {
54558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54559       };
54560     } catch (...) {
54561       {
54562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54563       };
54564     }
54565   }
54566
54567 }
54568
54569
54570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54571   unsigned int jresult ;
54572   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54573   bool result;
54574
54575   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54576   {
54577     try {
54578       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54579     } catch (std::out_of_range& e) {
54580       {
54581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54582       };
54583     } catch (std::exception& e) {
54584       {
54585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54586       };
54587     } catch (Dali::DaliException e) {
54588       {
54589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54590       };
54591     } catch (...) {
54592       {
54593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54594       };
54595     }
54596   }
54597
54598   jresult = result;
54599   return jresult;
54600 }
54601
54602
54603 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54604   unsigned long jresult ;
54605   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54606   std::size_t result;
54607
54608   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54609   {
54610     try {
54611       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54612     } catch (std::out_of_range& e) {
54613       {
54614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54615       };
54616     } catch (std::exception& e) {
54617       {
54618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54619       };
54620     } catch (Dali::DaliException e) {
54621       {
54622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54623       };
54624     } catch (...) {
54625       {
54626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54627       };
54628     }
54629   }
54630
54631   jresult = (unsigned long)result;
54632   return jresult;
54633 }
54634
54635
54636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54637   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54638   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54639
54640   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54641   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54642   {
54643     try {
54644       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54645     } catch (std::out_of_range& e) {
54646       {
54647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54648       };
54649     } catch (std::exception& e) {
54650       {
54651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54652       };
54653     } catch (Dali::DaliException e) {
54654       {
54655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54656       };
54657     } catch (...) {
54658       {
54659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54660       };
54661     }
54662   }
54663
54664 }
54665
54666
54667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54668   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54669   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54670
54671   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54672   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54673   {
54674     try {
54675       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54676     } catch (std::out_of_range& e) {
54677       {
54678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54679       };
54680     } catch (std::exception& e) {
54681       {
54682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54683       };
54684     } catch (Dali::DaliException e) {
54685       {
54686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54687       };
54688     } catch (...) {
54689       {
54690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54691       };
54692     }
54693   }
54694
54695 }
54696
54697
54698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54699   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54700   Dali::PropertyNotification *arg2 = 0 ;
54701
54702   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54703   arg2 = (Dali::PropertyNotification *)jarg2;
54704   if (!arg2) {
54705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54706     return ;
54707   }
54708   {
54709     try {
54710       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54711     } catch (std::out_of_range& e) {
54712       {
54713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54714       };
54715     } catch (std::exception& e) {
54716       {
54717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54718       };
54719     } catch (Dali::DaliException e) {
54720       {
54721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54722       };
54723     } catch (...) {
54724       {
54725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54726       };
54727     }
54728   }
54729
54730 }
54731
54732
54733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54734   void * jresult ;
54735   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54736
54737   {
54738     try {
54739       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54740     } catch (std::out_of_range& e) {
54741       {
54742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54743       };
54744     } catch (std::exception& e) {
54745       {
54746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54747       };
54748     } catch (Dali::DaliException e) {
54749       {
54750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54751       };
54752     } catch (...) {
54753       {
54754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54755       };
54756     }
54757   }
54758
54759   jresult = (void *)result;
54760   return jresult;
54761 }
54762
54763
54764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54765   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54766
54767   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54768   {
54769     try {
54770       delete arg1;
54771     } catch (std::out_of_range& e) {
54772       {
54773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54774       };
54775     } catch (std::exception& e) {
54776       {
54777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54778       };
54779     } catch (Dali::DaliException e) {
54780       {
54781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54782       };
54783     } catch (...) {
54784       {
54785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54786       };
54787     }
54788   }
54789
54790 }
54791
54792
54793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54794   unsigned int jresult ;
54795   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54796   bool result;
54797
54798   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54799   {
54800     try {
54801       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54802     } catch (std::out_of_range& e) {
54803       {
54804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54805       };
54806     } catch (std::exception& e) {
54807       {
54808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54809       };
54810     } catch (Dali::DaliException e) {
54811       {
54812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54813       };
54814     } catch (...) {
54815       {
54816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54817       };
54818     }
54819   }
54820
54821   jresult = result;
54822   return jresult;
54823 }
54824
54825
54826 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54827   unsigned long jresult ;
54828   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54829   std::size_t result;
54830
54831   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54832   {
54833     try {
54834       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54835     } catch (std::out_of_range& e) {
54836       {
54837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54838       };
54839     } catch (std::exception& e) {
54840       {
54841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54842       };
54843     } catch (Dali::DaliException e) {
54844       {
54845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54846       };
54847     } catch (...) {
54848       {
54849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54850       };
54851     }
54852   }
54853
54854   jresult = (unsigned long)result;
54855   return jresult;
54856 }
54857
54858
54859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54860   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54861   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54862
54863   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54864   arg2 = (void (*)(Dali::Image))jarg2;
54865   {
54866     try {
54867       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54868     } catch (std::out_of_range& e) {
54869       {
54870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54871       };
54872     } catch (std::exception& e) {
54873       {
54874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54875       };
54876     } catch (Dali::DaliException e) {
54877       {
54878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54879       };
54880     } catch (...) {
54881       {
54882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54883       };
54884     }
54885   }
54886
54887 }
54888
54889
54890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54891   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54892   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54893
54894   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54895   arg2 = (void (*)(Dali::Image))jarg2;
54896   {
54897     try {
54898       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54899     } catch (std::out_of_range& e) {
54900       {
54901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54902       };
54903     } catch (std::exception& e) {
54904       {
54905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54906       };
54907     } catch (Dali::DaliException e) {
54908       {
54909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54910       };
54911     } catch (...) {
54912       {
54913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54914       };
54915     }
54916   }
54917
54918 }
54919
54920
54921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54922   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54923   Dali::Image arg2 ;
54924   Dali::Image *argp2 ;
54925
54926   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54927   argp2 = (Dali::Image *)jarg2;
54928   if (!argp2) {
54929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54930     return ;
54931   }
54932   arg2 = *argp2;
54933   {
54934     try {
54935       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54936     } catch (std::out_of_range& e) {
54937       {
54938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54939       };
54940     } catch (std::exception& e) {
54941       {
54942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54943       };
54944     } catch (Dali::DaliException e) {
54945       {
54946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54947       };
54948     } catch (...) {
54949       {
54950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54951       };
54952     }
54953   }
54954
54955 }
54956
54957
54958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54959   void * jresult ;
54960   Dali::Signal< void (Dali::Image) > *result = 0 ;
54961
54962   {
54963     try {
54964       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54965     } catch (std::out_of_range& e) {
54966       {
54967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54968       };
54969     } catch (std::exception& e) {
54970       {
54971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54972       };
54973     } catch (Dali::DaliException e) {
54974       {
54975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54976       };
54977     } catch (...) {
54978       {
54979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54980       };
54981     }
54982   }
54983
54984   jresult = (void *)result;
54985   return jresult;
54986 }
54987
54988
54989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54990   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54991
54992   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54993   {
54994     try {
54995       delete arg1;
54996     } catch (std::out_of_range& e) {
54997       {
54998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54999       };
55000     } catch (std::exception& e) {
55001       {
55002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55003       };
55004     } catch (Dali::DaliException e) {
55005       {
55006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55007       };
55008     } catch (...) {
55009       {
55010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55011       };
55012     }
55013   }
55014
55015 }
55016
55017
55018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55019   void * jresult ;
55020   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55021
55022   {
55023     try {
55024       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55025     } catch (std::out_of_range& e) {
55026       {
55027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55028       };
55029     } catch (std::exception& e) {
55030       {
55031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55032       };
55033     } catch (Dali::DaliException e) {
55034       {
55035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55036       };
55037     } catch (...) {
55038       {
55039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55040       };
55041     }
55042   }
55043
55044   jresult = (void *)result;
55045   return jresult;
55046 }
55047
55048
55049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55050   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55051
55052   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55053   {
55054     try {
55055       delete arg1;
55056     } catch (std::out_of_range& e) {
55057       {
55058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55059       };
55060     } catch (std::exception& e) {
55061       {
55062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55063       };
55064     } catch (Dali::DaliException e) {
55065       {
55066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55067       };
55068     } catch (...) {
55069       {
55070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55071       };
55072     }
55073   }
55074
55075 }
55076
55077
55078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55079   unsigned int jresult ;
55080   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55081   bool result;
55082
55083   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55084   {
55085     try {
55086       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);
55087     } catch (std::out_of_range& e) {
55088       {
55089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55090       };
55091     } catch (std::exception& e) {
55092       {
55093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55094       };
55095     } catch (Dali::DaliException e) {
55096       {
55097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55098       };
55099     } catch (...) {
55100       {
55101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55102       };
55103     }
55104   }
55105
55106   jresult = result;
55107   return jresult;
55108 }
55109
55110
55111 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55112   unsigned long jresult ;
55113   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55114   std::size_t result;
55115
55116   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55117   {
55118     try {
55119       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);
55120     } catch (std::out_of_range& e) {
55121       {
55122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55123       };
55124     } catch (std::exception& e) {
55125       {
55126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55127       };
55128     } catch (Dali::DaliException e) {
55129       {
55130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55131       };
55132     } catch (...) {
55133       {
55134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55135       };
55136     }
55137   }
55138
55139   jresult = (unsigned long)result;
55140   return jresult;
55141 }
55142
55143
55144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55145   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55146   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55147
55148   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55149   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55150   {
55151     try {
55152       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55153     } catch (std::out_of_range& e) {
55154       {
55155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55156       };
55157     } catch (std::exception& e) {
55158       {
55159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55160       };
55161     } catch (Dali::DaliException e) {
55162       {
55163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55164       };
55165     } catch (...) {
55166       {
55167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55168       };
55169     }
55170   }
55171
55172 }
55173
55174
55175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55176   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55177   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55178
55179   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55180   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55181   {
55182     try {
55183       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55184     } catch (std::out_of_range& e) {
55185       {
55186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55187       };
55188     } catch (std::exception& e) {
55189       {
55190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55191       };
55192     } catch (Dali::DaliException e) {
55193       {
55194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55195       };
55196     } catch (...) {
55197       {
55198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55199       };
55200     }
55201   }
55202
55203 }
55204
55205
55206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55207   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55208   Dali::Actor arg2 ;
55209   Dali::LongPressGesture *arg3 = 0 ;
55210   Dali::Actor *argp2 ;
55211
55212   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55213   argp2 = (Dali::Actor *)jarg2;
55214   if (!argp2) {
55215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55216     return ;
55217   }
55218   arg2 = *argp2;
55219   arg3 = (Dali::LongPressGesture *)jarg3;
55220   if (!arg3) {
55221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55222     return ;
55223   }
55224   {
55225     try {
55226       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55227     } catch (std::out_of_range& e) {
55228       {
55229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55230       };
55231     } catch (std::exception& e) {
55232       {
55233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55234       };
55235     } catch (Dali::DaliException e) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55238       };
55239     } catch (...) {
55240       {
55241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55242       };
55243     }
55244   }
55245
55246 }
55247
55248
55249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55250   void * jresult ;
55251   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55252
55253   {
55254     try {
55255       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55256     } catch (std::out_of_range& e) {
55257       {
55258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55259       };
55260     } catch (std::exception& e) {
55261       {
55262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55263       };
55264     } catch (Dali::DaliException e) {
55265       {
55266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55267       };
55268     } catch (...) {
55269       {
55270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55271       };
55272     }
55273   }
55274
55275   jresult = (void *)result;
55276   return jresult;
55277 }
55278
55279
55280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55281   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55282
55283   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55284   {
55285     try {
55286       delete arg1;
55287     } catch (std::out_of_range& e) {
55288       {
55289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55290       };
55291     } catch (std::exception& e) {
55292       {
55293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55294       };
55295     } catch (Dali::DaliException e) {
55296       {
55297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55298       };
55299     } catch (...) {
55300       {
55301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55302       };
55303     }
55304   }
55305
55306 }
55307
55308
55309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55310   unsigned int jresult ;
55311   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55312   bool result;
55313
55314   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55315   {
55316     try {
55317       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);
55318     } catch (std::out_of_range& e) {
55319       {
55320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55321       };
55322     } catch (std::exception& e) {
55323       {
55324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55325       };
55326     } catch (Dali::DaliException e) {
55327       {
55328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55329       };
55330     } catch (...) {
55331       {
55332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55333       };
55334     }
55335   }
55336
55337   jresult = result;
55338   return jresult;
55339 }
55340
55341
55342 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55343   unsigned long jresult ;
55344   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55345   std::size_t result;
55346
55347   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55348   {
55349     try {
55350       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);
55351     } catch (std::out_of_range& e) {
55352       {
55353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55354       };
55355     } catch (std::exception& e) {
55356       {
55357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55358       };
55359     } catch (Dali::DaliException e) {
55360       {
55361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55362       };
55363     } catch (...) {
55364       {
55365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55366       };
55367     }
55368   }
55369
55370   jresult = (unsigned long)result;
55371   return jresult;
55372 }
55373
55374
55375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55376   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55377   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55378
55379   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55380   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55381   {
55382     try {
55383       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55384     } catch (std::out_of_range& e) {
55385       {
55386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55387       };
55388     } catch (std::exception& e) {
55389       {
55390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55391       };
55392     } catch (Dali::DaliException e) {
55393       {
55394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55395       };
55396     } catch (...) {
55397       {
55398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55399       };
55400     }
55401   }
55402
55403 }
55404
55405
55406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55407   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55408   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55409
55410   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55411   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55412   {
55413     try {
55414       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55415     } catch (std::out_of_range& e) {
55416       {
55417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55418       };
55419     } catch (std::exception& e) {
55420       {
55421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55422       };
55423     } catch (Dali::DaliException e) {
55424       {
55425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55426       };
55427     } catch (...) {
55428       {
55429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55430       };
55431     }
55432   }
55433
55434 }
55435
55436
55437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55438   unsigned int jresult ;
55439   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55440   Dali::Actor arg2 ;
55441   Dali::TouchData *arg3 = 0 ;
55442   Dali::Actor *argp2 ;
55443   bool result;
55444
55445   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55446   argp2 = (Dali::Actor *)jarg2;
55447   if (!argp2) {
55448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55449     return 0;
55450   }
55451   arg2 = *argp2;
55452   arg3 = (Dali::TouchData *)jarg3;
55453   if (!arg3) {
55454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55455     return 0;
55456   }
55457   {
55458     try {
55459       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55460     } catch (std::out_of_range& e) {
55461       {
55462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55463       };
55464     } catch (std::exception& e) {
55465       {
55466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55467       };
55468     } catch (Dali::DaliException e) {
55469       {
55470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55471       };
55472     } catch (...) {
55473       {
55474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55475       };
55476     }
55477   }
55478
55479   jresult = result;
55480   return jresult;
55481 }
55482
55483
55484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55485   void * jresult ;
55486   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55487
55488   {
55489     try {
55490       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55491     } catch (std::out_of_range& e) {
55492       {
55493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55494       };
55495     } catch (std::exception& e) {
55496       {
55497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55498       };
55499     } catch (Dali::DaliException e) {
55500       {
55501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55502       };
55503     } catch (...) {
55504       {
55505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55506       };
55507     }
55508   }
55509
55510   jresult = (void *)result;
55511   return jresult;
55512 }
55513
55514
55515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55516   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55517
55518   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55519   {
55520     try {
55521       delete arg1;
55522     } catch (std::out_of_range& e) {
55523       {
55524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55525       };
55526     } catch (std::exception& e) {
55527       {
55528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55529       };
55530     } catch (Dali::DaliException e) {
55531       {
55532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55533       };
55534     } catch (...) {
55535       {
55536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55537       };
55538     }
55539   }
55540
55541 }
55542
55543
55544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55545   unsigned int jresult ;
55546   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55547   bool result;
55548
55549   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55550   {
55551     try {
55552       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);
55553     } catch (std::out_of_range& e) {
55554       {
55555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55556       };
55557     } catch (std::exception& e) {
55558       {
55559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55560       };
55561     } catch (Dali::DaliException e) {
55562       {
55563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55564       };
55565     } catch (...) {
55566       {
55567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55568       };
55569     }
55570   }
55571
55572   jresult = result;
55573   return jresult;
55574 }
55575
55576
55577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55578   unsigned long jresult ;
55579   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55580   std::size_t result;
55581
55582   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55583   {
55584     try {
55585       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);
55586     } catch (std::out_of_range& e) {
55587       {
55588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55589       };
55590     } catch (std::exception& e) {
55591       {
55592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55593       };
55594     } catch (Dali::DaliException e) {
55595       {
55596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55597       };
55598     } catch (...) {
55599       {
55600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55601       };
55602     }
55603   }
55604
55605   jresult = (unsigned long)result;
55606   return jresult;
55607 }
55608
55609
55610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55611   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55612   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55613
55614   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55615   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55616   {
55617     try {
55618       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55619     } catch (std::out_of_range& e) {
55620       {
55621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55622       };
55623     } catch (std::exception& e) {
55624       {
55625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55626       };
55627     } catch (Dali::DaliException e) {
55628       {
55629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55630       };
55631     } catch (...) {
55632       {
55633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55634       };
55635     }
55636   }
55637
55638 }
55639
55640
55641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55642   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55643   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55644
55645   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55646   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55647   {
55648     try {
55649       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55650     } catch (std::out_of_range& e) {
55651       {
55652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55653       };
55654     } catch (std::exception& e) {
55655       {
55656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55657       };
55658     } catch (Dali::DaliException e) {
55659       {
55660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55661       };
55662     } catch (...) {
55663       {
55664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55665       };
55666     }
55667   }
55668
55669 }
55670
55671
55672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55673   unsigned int jresult ;
55674   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55675   Dali::Actor arg2 ;
55676   Dali::HoverEvent *arg3 = 0 ;
55677   Dali::Actor *argp2 ;
55678   bool result;
55679
55680   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55681   argp2 = (Dali::Actor *)jarg2;
55682   if (!argp2) {
55683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55684     return 0;
55685   }
55686   arg2 = *argp2;
55687   arg3 = (Dali::HoverEvent *)jarg3;
55688   if (!arg3) {
55689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55690     return 0;
55691   }
55692   {
55693     try {
55694       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55695     } catch (std::out_of_range& e) {
55696       {
55697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55698       };
55699     } catch (std::exception& e) {
55700       {
55701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55702       };
55703     } catch (Dali::DaliException e) {
55704       {
55705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55706       };
55707     } catch (...) {
55708       {
55709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55710       };
55711     }
55712   }
55713
55714   jresult = result;
55715   return jresult;
55716 }
55717
55718
55719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55720   void * jresult ;
55721   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55722
55723   {
55724     try {
55725       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55726     } catch (std::out_of_range& e) {
55727       {
55728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55729       };
55730     } catch (std::exception& e) {
55731       {
55732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55733       };
55734     } catch (Dali::DaliException e) {
55735       {
55736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55737       };
55738     } catch (...) {
55739       {
55740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55741       };
55742     }
55743   }
55744
55745   jresult = (void *)result;
55746   return jresult;
55747 }
55748
55749
55750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55751   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55752
55753   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55754   {
55755     try {
55756       delete arg1;
55757     } catch (std::out_of_range& e) {
55758       {
55759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55760       };
55761     } catch (std::exception& e) {
55762       {
55763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55764       };
55765     } catch (Dali::DaliException e) {
55766       {
55767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55768       };
55769     } catch (...) {
55770       {
55771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55772       };
55773     }
55774   }
55775
55776 }
55777
55778
55779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55780   unsigned int jresult ;
55781   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55782   bool result;
55783
55784   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55785   {
55786     try {
55787       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);
55788     } catch (std::out_of_range& e) {
55789       {
55790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55791       };
55792     } catch (std::exception& e) {
55793       {
55794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55795       };
55796     } catch (Dali::DaliException e) {
55797       {
55798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55799       };
55800     } catch (...) {
55801       {
55802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55803       };
55804     }
55805   }
55806
55807   jresult = result;
55808   return jresult;
55809 }
55810
55811
55812 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55813   unsigned long jresult ;
55814   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55815   std::size_t result;
55816
55817   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55818   {
55819     try {
55820       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);
55821     } catch (std::out_of_range& e) {
55822       {
55823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55824       };
55825     } catch (std::exception& e) {
55826       {
55827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55828       };
55829     } catch (Dali::DaliException e) {
55830       {
55831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55832       };
55833     } catch (...) {
55834       {
55835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55836       };
55837     }
55838   }
55839
55840   jresult = (unsigned long)result;
55841   return jresult;
55842 }
55843
55844
55845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55846   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55847   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55848
55849   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55850   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55851   {
55852     try {
55853       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55854     } catch (std::out_of_range& e) {
55855       {
55856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55857       };
55858     } catch (std::exception& e) {
55859       {
55860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55861       };
55862     } catch (Dali::DaliException e) {
55863       {
55864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55865       };
55866     } catch (...) {
55867       {
55868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55869       };
55870     }
55871   }
55872
55873 }
55874
55875
55876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55877   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55878   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55879
55880   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55881   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55882   {
55883     try {
55884       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55885     } catch (std::out_of_range& e) {
55886       {
55887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55888       };
55889     } catch (std::exception& e) {
55890       {
55891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55892       };
55893     } catch (Dali::DaliException e) {
55894       {
55895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55896       };
55897     } catch (...) {
55898       {
55899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55900       };
55901     }
55902   }
55903
55904 }
55905
55906
55907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55908   unsigned int jresult ;
55909   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55910   Dali::Actor arg2 ;
55911   Dali::WheelEvent *arg3 = 0 ;
55912   Dali::Actor *argp2 ;
55913   bool result;
55914
55915   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55916   argp2 = (Dali::Actor *)jarg2;
55917   if (!argp2) {
55918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55919     return 0;
55920   }
55921   arg2 = *argp2;
55922   arg3 = (Dali::WheelEvent *)jarg3;
55923   if (!arg3) {
55924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55925     return 0;
55926   }
55927   {
55928     try {
55929       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55930     } catch (std::out_of_range& e) {
55931       {
55932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55933       };
55934     } catch (std::exception& e) {
55935       {
55936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55937       };
55938     } catch (Dali::DaliException e) {
55939       {
55940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55941       };
55942     } catch (...) {
55943       {
55944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55945       };
55946     }
55947   }
55948
55949   jresult = result;
55950   return jresult;
55951 }
55952
55953
55954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55955   void * jresult ;
55956   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55957
55958   {
55959     try {
55960       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55961     } catch (std::out_of_range& e) {
55962       {
55963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55964       };
55965     } catch (std::exception& e) {
55966       {
55967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55968       };
55969     } catch (Dali::DaliException e) {
55970       {
55971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55972       };
55973     } catch (...) {
55974       {
55975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55976       };
55977     }
55978   }
55979
55980   jresult = (void *)result;
55981   return jresult;
55982 }
55983
55984
55985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55986   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55987
55988   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55989   {
55990     try {
55991       delete arg1;
55992     } catch (std::out_of_range& e) {
55993       {
55994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55995       };
55996     } catch (std::exception& e) {
55997       {
55998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55999       };
56000     } catch (Dali::DaliException e) {
56001       {
56002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56003       };
56004     } catch (...) {
56005       {
56006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56007       };
56008     }
56009   }
56010
56011 }
56012
56013
56014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56015   unsigned int jresult ;
56016   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56017   bool result;
56018
56019   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56020   {
56021     try {
56022       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56023     } catch (std::out_of_range& e) {
56024       {
56025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56026       };
56027     } catch (std::exception& e) {
56028       {
56029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56030       };
56031     } catch (Dali::DaliException e) {
56032       {
56033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56034       };
56035     } catch (...) {
56036       {
56037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56038       };
56039     }
56040   }
56041
56042   jresult = result;
56043   return jresult;
56044 }
56045
56046
56047 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56048   unsigned long jresult ;
56049   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56050   std::size_t result;
56051
56052   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56053   {
56054     try {
56055       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56056     } catch (std::out_of_range& e) {
56057       {
56058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56059       };
56060     } catch (std::exception& e) {
56061       {
56062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56063       };
56064     } catch (Dali::DaliException e) {
56065       {
56066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56067       };
56068     } catch (...) {
56069       {
56070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56071       };
56072     }
56073   }
56074
56075   jresult = (unsigned long)result;
56076   return jresult;
56077 }
56078
56079
56080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56081   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56082   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56083
56084   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56085   arg2 = (void (*)(Dali::Actor))jarg2;
56086   {
56087     try {
56088       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56089     } catch (std::out_of_range& e) {
56090       {
56091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56092       };
56093     } catch (std::exception& e) {
56094       {
56095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56096       };
56097     } catch (Dali::DaliException e) {
56098       {
56099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56100       };
56101     } catch (...) {
56102       {
56103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56104       };
56105     }
56106   }
56107
56108 }
56109
56110
56111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56112   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56113   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56114
56115   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56116   arg2 = (void (*)(Dali::Actor))jarg2;
56117   {
56118     try {
56119       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56120     } catch (std::out_of_range& e) {
56121       {
56122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56123       };
56124     } catch (std::exception& e) {
56125       {
56126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56127       };
56128     } catch (Dali::DaliException e) {
56129       {
56130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56131       };
56132     } catch (...) {
56133       {
56134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56135       };
56136     }
56137   }
56138
56139 }
56140
56141
56142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56143   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56144   Dali::Actor arg2 ;
56145   Dali::Actor *argp2 ;
56146
56147   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56148   argp2 = (Dali::Actor *)jarg2;
56149   if (!argp2) {
56150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56151     return ;
56152   }
56153   arg2 = *argp2;
56154   {
56155     try {
56156       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56157     } catch (std::out_of_range& e) {
56158       {
56159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56160       };
56161     } catch (std::exception& e) {
56162       {
56163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56164       };
56165     } catch (Dali::DaliException e) {
56166       {
56167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56168       };
56169     } catch (...) {
56170       {
56171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56172       };
56173     }
56174   }
56175
56176 }
56177
56178
56179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56180   void * jresult ;
56181   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56182
56183   {
56184     try {
56185       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56186     } catch (std::out_of_range& e) {
56187       {
56188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56189       };
56190     } catch (std::exception& e) {
56191       {
56192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56193       };
56194     } catch (Dali::DaliException e) {
56195       {
56196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56197       };
56198     } catch (...) {
56199       {
56200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56201       };
56202     }
56203   }
56204
56205   jresult = (void *)result;
56206   return jresult;
56207 }
56208
56209
56210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56211   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56212
56213   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56214   {
56215     try {
56216       delete arg1;
56217     } catch (std::out_of_range& e) {
56218       {
56219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56220       };
56221     } catch (std::exception& e) {
56222       {
56223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56224       };
56225     } catch (Dali::DaliException e) {
56226       {
56227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56228       };
56229     } catch (...) {
56230       {
56231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56232       };
56233     }
56234   }
56235
56236 }
56237
56238
56239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56240   unsigned int jresult ;
56241   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56242   bool result;
56243
56244   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56245   {
56246     try {
56247       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56248     } catch (std::out_of_range& e) {
56249       {
56250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56251       };
56252     } catch (std::exception& e) {
56253       {
56254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56255       };
56256     } catch (Dali::DaliException e) {
56257       {
56258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56259       };
56260     } catch (...) {
56261       {
56262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56263       };
56264     }
56265   }
56266
56267   jresult = result;
56268   return jresult;
56269 }
56270
56271
56272 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56273   unsigned long jresult ;
56274   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56275   std::size_t result;
56276
56277   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56278   {
56279     try {
56280       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56281     } catch (std::out_of_range& e) {
56282       {
56283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56284       };
56285     } catch (std::exception& e) {
56286       {
56287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56288       };
56289     } catch (Dali::DaliException e) {
56290       {
56291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56292       };
56293     } catch (...) {
56294       {
56295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56296       };
56297     }
56298   }
56299
56300   jresult = (unsigned long)result;
56301   return jresult;
56302 }
56303
56304
56305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56306   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56307   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56308
56309   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56310   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56311   {
56312     try {
56313       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56314     } catch (std::out_of_range& e) {
56315       {
56316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56317       };
56318     } catch (std::exception& e) {
56319       {
56320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56321       };
56322     } catch (Dali::DaliException e) {
56323       {
56324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56325       };
56326     } catch (...) {
56327       {
56328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56329       };
56330     }
56331   }
56332
56333 }
56334
56335
56336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56337   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56338   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56339
56340   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56341   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56342   {
56343     try {
56344       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56345     } catch (std::out_of_range& e) {
56346       {
56347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56348       };
56349     } catch (std::exception& e) {
56350       {
56351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56352       };
56353     } catch (Dali::DaliException e) {
56354       {
56355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56356       };
56357     } catch (...) {
56358       {
56359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56360       };
56361     }
56362   }
56363
56364 }
56365
56366
56367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56368   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56369   Dali::KeyEvent *arg2 = 0 ;
56370
56371   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56372   arg2 = (Dali::KeyEvent *)jarg2;
56373   if (!arg2) {
56374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56375     return ;
56376   }
56377   {
56378     try {
56379       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56380     } catch (std::out_of_range& e) {
56381       {
56382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56383       };
56384     } catch (std::exception& e) {
56385       {
56386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56387       };
56388     } catch (Dali::DaliException e) {
56389       {
56390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56391       };
56392     } catch (...) {
56393       {
56394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56395       };
56396     }
56397   }
56398
56399 }
56400
56401
56402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56403   void * jresult ;
56404   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56405
56406   {
56407     try {
56408       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56409     } catch (std::out_of_range& e) {
56410       {
56411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56412       };
56413     } catch (std::exception& e) {
56414       {
56415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56416       };
56417     } catch (Dali::DaliException e) {
56418       {
56419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56420       };
56421     } catch (...) {
56422       {
56423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56424       };
56425     }
56426   }
56427
56428   jresult = (void *)result;
56429   return jresult;
56430 }
56431
56432
56433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56434   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56435
56436   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56437   {
56438     try {
56439       delete arg1;
56440     } catch (std::out_of_range& e) {
56441       {
56442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56443       };
56444     } catch (std::exception& e) {
56445       {
56446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56447       };
56448     } catch (Dali::DaliException e) {
56449       {
56450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56451       };
56452     } catch (...) {
56453       {
56454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56455       };
56456     }
56457   }
56458
56459 }
56460
56461
56462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56463   unsigned int jresult ;
56464   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56465   bool result;
56466
56467   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56468   {
56469     try {
56470       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56471     } catch (std::out_of_range& e) {
56472       {
56473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56474       };
56475     } catch (std::exception& e) {
56476       {
56477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56478       };
56479     } catch (Dali::DaliException e) {
56480       {
56481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56482       };
56483     } catch (...) {
56484       {
56485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56486       };
56487     }
56488   }
56489
56490   jresult = result;
56491   return jresult;
56492 }
56493
56494
56495 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56496   unsigned long jresult ;
56497   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56498   std::size_t result;
56499
56500   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56501   {
56502     try {
56503       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56504     } catch (std::out_of_range& e) {
56505       {
56506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56507       };
56508     } catch (std::exception& e) {
56509       {
56510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56511       };
56512     } catch (Dali::DaliException e) {
56513       {
56514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56515       };
56516     } catch (...) {
56517       {
56518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56519       };
56520     }
56521   }
56522
56523   jresult = (unsigned long)result;
56524   return jresult;
56525 }
56526
56527
56528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56529   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56530   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56531
56532   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56533   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56534   {
56535     try {
56536       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56537     } catch (std::out_of_range& e) {
56538       {
56539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56540       };
56541     } catch (std::exception& e) {
56542       {
56543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56544       };
56545     } catch (Dali::DaliException e) {
56546       {
56547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56548       };
56549     } catch (...) {
56550       {
56551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56552       };
56553     }
56554   }
56555
56556 }
56557
56558
56559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56560   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56561   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56562
56563   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56564   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56565   {
56566     try {
56567       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56568     } catch (std::out_of_range& e) {
56569       {
56570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56571       };
56572     } catch (std::exception& e) {
56573       {
56574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56575       };
56576     } catch (Dali::DaliException e) {
56577       {
56578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56579       };
56580     } catch (...) {
56581       {
56582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56583       };
56584     }
56585   }
56586
56587 }
56588
56589
56590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56591   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56592   Dali::TouchData *arg2 = 0 ;
56593
56594   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56595   arg2 = (Dali::TouchData *)jarg2;
56596   if (!arg2) {
56597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56598     return ;
56599   }
56600   {
56601     try {
56602       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56603     } catch (std::out_of_range& e) {
56604       {
56605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56606       };
56607     } catch (std::exception& e) {
56608       {
56609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56610       };
56611     } catch (Dali::DaliException e) {
56612       {
56613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56614       };
56615     } catch (...) {
56616       {
56617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56618       };
56619     }
56620   }
56621
56622 }
56623
56624
56625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56626   void * jresult ;
56627   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56628
56629   {
56630     try {
56631       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56632     } catch (std::out_of_range& e) {
56633       {
56634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56635       };
56636     } catch (std::exception& e) {
56637       {
56638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56639       };
56640     } catch (Dali::DaliException e) {
56641       {
56642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56643       };
56644     } catch (...) {
56645       {
56646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56647       };
56648     }
56649   }
56650
56651   jresult = (void *)result;
56652   return jresult;
56653 }
56654
56655
56656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56657   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56658
56659   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56660   {
56661     try {
56662       delete arg1;
56663     } catch (std::out_of_range& e) {
56664       {
56665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56666       };
56667     } catch (std::exception& e) {
56668       {
56669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56670       };
56671     } catch (Dali::DaliException e) {
56672       {
56673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56674       };
56675     } catch (...) {
56676       {
56677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56678       };
56679     }
56680   }
56681
56682 }
56683
56684
56685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56686   unsigned int jresult ;
56687   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56688   bool result;
56689
56690   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56691   {
56692     try {
56693       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56694     } catch (std::out_of_range& e) {
56695       {
56696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56697       };
56698     } catch (std::exception& e) {
56699       {
56700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56701       };
56702     } catch (Dali::DaliException e) {
56703       {
56704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56705       };
56706     } catch (...) {
56707       {
56708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56709       };
56710     }
56711   }
56712
56713   jresult = result;
56714   return jresult;
56715 }
56716
56717
56718 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56719   unsigned long jresult ;
56720   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56721   std::size_t result;
56722
56723   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56724   {
56725     try {
56726       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56727     } catch (std::out_of_range& e) {
56728       {
56729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56730       };
56731     } catch (std::exception& e) {
56732       {
56733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56734       };
56735     } catch (Dali::DaliException e) {
56736       {
56737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56738       };
56739     } catch (...) {
56740       {
56741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56742       };
56743     }
56744   }
56745
56746   jresult = (unsigned long)result;
56747   return jresult;
56748 }
56749
56750
56751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56752   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56753   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56754
56755   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56756   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56757   {
56758     try {
56759       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56760     } catch (std::out_of_range& e) {
56761       {
56762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56763       };
56764     } catch (std::exception& e) {
56765       {
56766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56767       };
56768     } catch (Dali::DaliException e) {
56769       {
56770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56771       };
56772     } catch (...) {
56773       {
56774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56775       };
56776     }
56777   }
56778
56779 }
56780
56781
56782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56783   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56784   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56785
56786   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56787   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56788   {
56789     try {
56790       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56791     } catch (std::out_of_range& e) {
56792       {
56793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56794       };
56795     } catch (std::exception& e) {
56796       {
56797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56798       };
56799     } catch (Dali::DaliException e) {
56800       {
56801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56802       };
56803     } catch (...) {
56804       {
56805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56806       };
56807     }
56808   }
56809
56810 }
56811
56812
56813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56814   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56815   Dali::WheelEvent *arg2 = 0 ;
56816
56817   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56818   arg2 = (Dali::WheelEvent *)jarg2;
56819   if (!arg2) {
56820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56821     return ;
56822   }
56823   {
56824     try {
56825       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56826     } catch (std::out_of_range& e) {
56827       {
56828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56829       };
56830     } catch (std::exception& e) {
56831       {
56832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56833       };
56834     } catch (Dali::DaliException e) {
56835       {
56836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56837       };
56838     } catch (...) {
56839       {
56840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56841       };
56842     }
56843   }
56844
56845 }
56846
56847
56848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56849   void * jresult ;
56850   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56851
56852   {
56853     try {
56854       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56855     } catch (std::out_of_range& e) {
56856       {
56857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56858       };
56859     } catch (std::exception& e) {
56860       {
56861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56862       };
56863     } catch (Dali::DaliException e) {
56864       {
56865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56866       };
56867     } catch (...) {
56868       {
56869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56870       };
56871     }
56872   }
56873
56874   jresult = (void *)result;
56875   return jresult;
56876 }
56877
56878
56879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56880   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56881
56882   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56883   {
56884     try {
56885       delete arg1;
56886     } catch (std::out_of_range& e) {
56887       {
56888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56889       };
56890     } catch (std::exception& e) {
56891       {
56892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56893       };
56894     } catch (Dali::DaliException e) {
56895       {
56896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56897       };
56898     } catch (...) {
56899       {
56900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56901       };
56902     }
56903   }
56904
56905 }
56906
56907
56908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56909   void * jresult ;
56910   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56911
56912   {
56913     try {
56914       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56915     } catch (std::out_of_range& e) {
56916       {
56917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56918       };
56919     } catch (std::exception& e) {
56920       {
56921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56922       };
56923     } catch (Dali::DaliException e) {
56924       {
56925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56926       };
56927     } catch (...) {
56928       {
56929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56930       };
56931     }
56932   }
56933
56934   jresult = (void *)result;
56935   return jresult;
56936 }
56937
56938
56939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56940   void * jresult ;
56941   Dali::Radian arg1 ;
56942   Dali::Radian arg2 ;
56943   Dali::Radian *argp1 ;
56944   Dali::Radian *argp2 ;
56945   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56946
56947   argp1 = (Dali::Radian *)jarg1;
56948   if (!argp1) {
56949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56950     return 0;
56951   }
56952   arg1 = *argp1;
56953   argp2 = (Dali::Radian *)jarg2;
56954   if (!argp2) {
56955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56956     return 0;
56957   }
56958   arg2 = *argp2;
56959   {
56960     try {
56961       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56962     } catch (std::out_of_range& e) {
56963       {
56964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56965       };
56966     } catch (std::exception& e) {
56967       {
56968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56969       };
56970     } catch (Dali::DaliException e) {
56971       {
56972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56973       };
56974     } catch (...) {
56975       {
56976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56977       };
56978     }
56979   }
56980
56981   jresult = (void *)result;
56982   return jresult;
56983 }
56984
56985
56986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56987   void * jresult ;
56988   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56989   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56990
56991   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56992   if (!arg1) {
56993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56994     return 0;
56995   }
56996   {
56997     try {
56998       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56999     } catch (std::out_of_range& e) {
57000       {
57001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57002       };
57003     } catch (std::exception& e) {
57004       {
57005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57006       };
57007     } catch (Dali::DaliException e) {
57008       {
57009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57010       };
57011     } catch (...) {
57012       {
57013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57014       };
57015     }
57016   }
57017
57018   jresult = (void *)result;
57019   return jresult;
57020 }
57021
57022
57023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57024   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57025   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57026
57027   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57028   arg2 = (Dali::Radian *)jarg2;
57029   if (arg1) (arg1)->first = *arg2;
57030 }
57031
57032
57033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57034   void * jresult ;
57035   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57036   Dali::Radian *result = 0 ;
57037
57038   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57039   result = (Dali::Radian *)& ((arg1)->first);
57040   jresult = (void *)result;
57041   return jresult;
57042 }
57043
57044
57045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57046   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57047   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57048
57049   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57050   arg2 = (Dali::Radian *)jarg2;
57051   if (arg1) (arg1)->second = *arg2;
57052 }
57053
57054
57055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57056   void * jresult ;
57057   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57058   Dali::Radian *result = 0 ;
57059
57060   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57061   result = (Dali::Radian *)& ((arg1)->second);
57062   jresult = (void *)result;
57063   return jresult;
57064 }
57065
57066
57067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57068   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57069
57070   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57071   {
57072     try {
57073       delete arg1;
57074     } catch (std::out_of_range& e) {
57075       {
57076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57077       };
57078     } catch (std::exception& e) {
57079       {
57080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57081       };
57082     } catch (Dali::DaliException e) {
57083       {
57084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57085       };
57086     } catch (...) {
57087       {
57088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57089       };
57090     }
57091   }
57092
57093 }
57094
57095
57096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57097   unsigned int jresult ;
57098   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57099   bool result;
57100
57101   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57102   {
57103     try {
57104       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);
57105     } catch (std::out_of_range& e) {
57106       {
57107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57108       };
57109     } catch (std::exception& e) {
57110       {
57111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57112       };
57113     } catch (Dali::DaliException e) {
57114       {
57115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57116       };
57117     } catch (...) {
57118       {
57119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57120       };
57121     }
57122   }
57123
57124   jresult = result;
57125   return jresult;
57126 }
57127
57128
57129 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57130   unsigned long jresult ;
57131   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57132   std::size_t result;
57133
57134   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57135   {
57136     try {
57137       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);
57138     } catch (std::out_of_range& e) {
57139       {
57140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57141       };
57142     } catch (std::exception& e) {
57143       {
57144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57145       };
57146     } catch (Dali::DaliException e) {
57147       {
57148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57149       };
57150     } catch (...) {
57151       {
57152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57153       };
57154     }
57155   }
57156
57157   jresult = (unsigned long)result;
57158   return jresult;
57159 }
57160
57161
57162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57163   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57164   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57165
57166   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57167   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57168   {
57169     try {
57170       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57171     } catch (std::out_of_range& e) {
57172       {
57173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57174       };
57175     } catch (std::exception& e) {
57176       {
57177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57178       };
57179     } catch (Dali::DaliException e) {
57180       {
57181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57182       };
57183     } catch (...) {
57184       {
57185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57186       };
57187     }
57188   }
57189
57190 }
57191
57192
57193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57194   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57195   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57196
57197   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57198   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57199   {
57200     try {
57201       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57202     } catch (std::out_of_range& e) {
57203       {
57204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57205       };
57206     } catch (std::exception& e) {
57207       {
57208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57209       };
57210     } catch (Dali::DaliException e) {
57211       {
57212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57213       };
57214     } catch (...) {
57215       {
57216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57217       };
57218     }
57219   }
57220
57221 }
57222
57223
57224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57225   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57226   Dali::Actor arg2 ;
57227   Dali::PanGesture *arg3 = 0 ;
57228   Dali::Actor *argp2 ;
57229
57230   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57231   argp2 = (Dali::Actor *)jarg2;
57232   if (!argp2) {
57233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57234     return ;
57235   }
57236   arg2 = *argp2;
57237   arg3 = (Dali::PanGesture *)jarg3;
57238   if (!arg3) {
57239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57240     return ;
57241   }
57242   {
57243     try {
57244       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57245     } catch (std::out_of_range& e) {
57246       {
57247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57248       };
57249     } catch (std::exception& e) {
57250       {
57251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57252       };
57253     } catch (Dali::DaliException e) {
57254       {
57255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57256       };
57257     } catch (...) {
57258       {
57259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57260       };
57261     }
57262   }
57263
57264 }
57265
57266
57267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57268   void * jresult ;
57269   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57270
57271   {
57272     try {
57273       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57274     } catch (std::out_of_range& e) {
57275       {
57276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57277       };
57278     } catch (std::exception& e) {
57279       {
57280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57281       };
57282     } catch (Dali::DaliException e) {
57283       {
57284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57285       };
57286     } catch (...) {
57287       {
57288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57289       };
57290     }
57291   }
57292
57293   jresult = (void *)result;
57294   return jresult;
57295 }
57296
57297
57298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57299   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57300
57301   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57302   {
57303     try {
57304       delete arg1;
57305     } catch (std::out_of_range& e) {
57306       {
57307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57308       };
57309     } catch (std::exception& e) {
57310       {
57311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57312       };
57313     } catch (Dali::DaliException e) {
57314       {
57315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57316       };
57317     } catch (...) {
57318       {
57319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57320       };
57321     }
57322   }
57323
57324 }
57325
57326
57327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57328   unsigned int jresult ;
57329   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57330   bool result;
57331
57332   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57333   {
57334     try {
57335       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);
57336     } catch (std::out_of_range& e) {
57337       {
57338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57339       };
57340     } catch (std::exception& e) {
57341       {
57342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57343       };
57344     } catch (Dali::DaliException e) {
57345       {
57346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57347       };
57348     } catch (...) {
57349       {
57350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57351       };
57352     }
57353   }
57354
57355   jresult = result;
57356   return jresult;
57357 }
57358
57359
57360 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57361   unsigned long jresult ;
57362   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57363   std::size_t result;
57364
57365   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57366   {
57367     try {
57368       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);
57369     } catch (std::out_of_range& e) {
57370       {
57371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57372       };
57373     } catch (std::exception& e) {
57374       {
57375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57376       };
57377     } catch (Dali::DaliException e) {
57378       {
57379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57380       };
57381     } catch (...) {
57382       {
57383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57384       };
57385     }
57386   }
57387
57388   jresult = (unsigned long)result;
57389   return jresult;
57390 }
57391
57392
57393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57394   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57395   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57396
57397   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57398   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57399   {
57400     try {
57401       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57402     } catch (std::out_of_range& e) {
57403       {
57404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57405       };
57406     } catch (std::exception& e) {
57407       {
57408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57409       };
57410     } catch (Dali::DaliException e) {
57411       {
57412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57413       };
57414     } catch (...) {
57415       {
57416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57417       };
57418     }
57419   }
57420
57421 }
57422
57423
57424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57425   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57426   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57427
57428   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57429   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57430   {
57431     try {
57432       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57433     } catch (std::out_of_range& e) {
57434       {
57435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57436       };
57437     } catch (std::exception& e) {
57438       {
57439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57440       };
57441     } catch (Dali::DaliException e) {
57442       {
57443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57444       };
57445     } catch (...) {
57446       {
57447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57448       };
57449     }
57450   }
57451
57452 }
57453
57454
57455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57456   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57457   Dali::Actor arg2 ;
57458   Dali::PinchGesture *arg3 = 0 ;
57459   Dali::Actor *argp2 ;
57460
57461   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57462   argp2 = (Dali::Actor *)jarg2;
57463   if (!argp2) {
57464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57465     return ;
57466   }
57467   arg2 = *argp2;
57468   arg3 = (Dali::PinchGesture *)jarg3;
57469   if (!arg3) {
57470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57471     return ;
57472   }
57473   {
57474     try {
57475       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57476     } catch (std::out_of_range& e) {
57477       {
57478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57479       };
57480     } catch (std::exception& e) {
57481       {
57482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57483       };
57484     } catch (Dali::DaliException e) {
57485       {
57486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57487       };
57488     } catch (...) {
57489       {
57490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57491       };
57492     }
57493   }
57494
57495 }
57496
57497
57498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57499   void * jresult ;
57500   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57501
57502   {
57503     try {
57504       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57505     } catch (std::out_of_range& e) {
57506       {
57507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57508       };
57509     } catch (std::exception& e) {
57510       {
57511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57512       };
57513     } catch (Dali::DaliException e) {
57514       {
57515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57516       };
57517     } catch (...) {
57518       {
57519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57520       };
57521     }
57522   }
57523
57524   jresult = (void *)result;
57525   return jresult;
57526 }
57527
57528
57529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57530   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57531
57532   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57533   {
57534     try {
57535       delete arg1;
57536     } catch (std::out_of_range& e) {
57537       {
57538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57539       };
57540     } catch (std::exception& e) {
57541       {
57542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57543       };
57544     } catch (Dali::DaliException e) {
57545       {
57546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57547       };
57548     } catch (...) {
57549       {
57550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57551       };
57552     }
57553   }
57554
57555 }
57556
57557
57558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57559   unsigned int jresult ;
57560   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57561   bool result;
57562
57563   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57564   {
57565     try {
57566       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);
57567     } catch (std::out_of_range& e) {
57568       {
57569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57570       };
57571     } catch (std::exception& e) {
57572       {
57573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57574       };
57575     } catch (Dali::DaliException e) {
57576       {
57577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57578       };
57579     } catch (...) {
57580       {
57581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57582       };
57583     }
57584   }
57585
57586   jresult = result;
57587   return jresult;
57588 }
57589
57590
57591 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57592   unsigned long jresult ;
57593   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57594   std::size_t result;
57595
57596   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57597   {
57598     try {
57599       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);
57600     } catch (std::out_of_range& e) {
57601       {
57602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57603       };
57604     } catch (std::exception& e) {
57605       {
57606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57607       };
57608     } catch (Dali::DaliException e) {
57609       {
57610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57611       };
57612     } catch (...) {
57613       {
57614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57615       };
57616     }
57617   }
57618
57619   jresult = (unsigned long)result;
57620   return jresult;
57621 }
57622
57623
57624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57625   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57626   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57627
57628   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57629   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57630   {
57631     try {
57632       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57633     } catch (std::out_of_range& e) {
57634       {
57635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57636       };
57637     } catch (std::exception& e) {
57638       {
57639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57640       };
57641     } catch (Dali::DaliException e) {
57642       {
57643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57644       };
57645     } catch (...) {
57646       {
57647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57648       };
57649     }
57650   }
57651
57652 }
57653
57654
57655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57656   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57657   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57658
57659   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57660   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57661   {
57662     try {
57663       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57664     } catch (std::out_of_range& e) {
57665       {
57666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57667       };
57668     } catch (std::exception& e) {
57669       {
57670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57671       };
57672     } catch (Dali::DaliException e) {
57673       {
57674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57675       };
57676     } catch (...) {
57677       {
57678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57679       };
57680     }
57681   }
57682
57683 }
57684
57685
57686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57687   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57688   Dali::Actor arg2 ;
57689   Dali::TapGesture *arg3 = 0 ;
57690   Dali::Actor *argp2 ;
57691
57692   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57693   argp2 = (Dali::Actor *)jarg2;
57694   if (!argp2) {
57695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57696     return ;
57697   }
57698   arg2 = *argp2;
57699   arg3 = (Dali::TapGesture *)jarg3;
57700   if (!arg3) {
57701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57702     return ;
57703   }
57704   {
57705     try {
57706       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57707     } catch (std::out_of_range& e) {
57708       {
57709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57710       };
57711     } catch (std::exception& e) {
57712       {
57713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57714       };
57715     } catch (Dali::DaliException e) {
57716       {
57717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57718       };
57719     } catch (...) {
57720       {
57721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57722       };
57723     }
57724   }
57725
57726 }
57727
57728
57729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57730   void * jresult ;
57731   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57732
57733   {
57734     try {
57735       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57736     } catch (std::out_of_range& e) {
57737       {
57738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57739       };
57740     } catch (std::exception& e) {
57741       {
57742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57743       };
57744     } catch (Dali::DaliException e) {
57745       {
57746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57747       };
57748     } catch (...) {
57749       {
57750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57751       };
57752     }
57753   }
57754
57755   jresult = (void *)result;
57756   return jresult;
57757 }
57758
57759
57760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57761   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57762
57763   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57764   {
57765     try {
57766       delete arg1;
57767     } catch (std::out_of_range& e) {
57768       {
57769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57770       };
57771     } catch (std::exception& e) {
57772       {
57773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57774       };
57775     } catch (Dali::DaliException e) {
57776       {
57777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57778       };
57779     } catch (...) {
57780       {
57781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57782       };
57783     }
57784   }
57785
57786 }
57787
57788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57789   unsigned int jresult ;
57790   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57791   bool result;
57792
57793   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57794   {
57795     try {
57796       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57797     } catch (std::out_of_range& e) {
57798       {
57799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57800       };
57801     } catch (std::exception& e) {
57802       {
57803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57804       };
57805     } catch (Dali::DaliException e) {
57806       {
57807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57808       };
57809     } catch (...) {
57810       {
57811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57812       };
57813     }
57814   }
57815
57816   jresult = result;
57817   return jresult;
57818 }
57819
57820
57821 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57822   unsigned long jresult ;
57823   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57824   std::size_t result;
57825
57826   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57827   {
57828     try {
57829       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57830     } catch (std::out_of_range& e) {
57831       {
57832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57833       };
57834     } catch (std::exception& e) {
57835       {
57836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57837       };
57838     } catch (Dali::DaliException e) {
57839       {
57840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57841       };
57842     } catch (...) {
57843       {
57844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57845       };
57846     }
57847   }
57848
57849   jresult = (unsigned long)result;
57850   return jresult;
57851 }
57852
57853
57854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57855   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57856   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57857
57858   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57859   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57860   {
57861     try {
57862       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57863     } catch (std::out_of_range& e) {
57864       {
57865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57866       };
57867     } catch (std::exception& e) {
57868       {
57869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57870       };
57871     } catch (Dali::DaliException e) {
57872       {
57873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57874       };
57875     } catch (...) {
57876       {
57877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57878       };
57879     }
57880   }
57881
57882 }
57883
57884
57885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57886   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57887   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57888
57889   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57890   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57891   {
57892     try {
57893       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57894     } catch (std::out_of_range& e) {
57895       {
57896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57897       };
57898     } catch (std::exception& e) {
57899       {
57900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57901       };
57902     } catch (Dali::DaliException e) {
57903       {
57904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57905       };
57906     } catch (...) {
57907       {
57908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57909       };
57910     }
57911   }
57912
57913 }
57914
57915
57916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57917   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57918   Dali::ResourceImage arg2 ;
57919   Dali::ResourceImage *argp2 ;
57920
57921   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57922   argp2 = (Dali::ResourceImage *)jarg2;
57923   if (!argp2) {
57924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57925     return ;
57926   }
57927   arg2 = *argp2;
57928   {
57929     try {
57930       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57931     } catch (std::out_of_range& e) {
57932       {
57933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57934       };
57935     } catch (std::exception& e) {
57936       {
57937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57938       };
57939     } catch (Dali::DaliException e) {
57940       {
57941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57942       };
57943     } catch (...) {
57944       {
57945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57946       };
57947     }
57948   }
57949
57950 }
57951
57952
57953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57954   void * jresult ;
57955   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57956
57957   {
57958     try {
57959       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57960     } catch (std::out_of_range& e) {
57961       {
57962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57963       };
57964     } catch (std::exception& e) {
57965       {
57966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57967       };
57968     } catch (Dali::DaliException e) {
57969       {
57970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57971       };
57972     } catch (...) {
57973       {
57974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57975       };
57976     }
57977   }
57978
57979   jresult = (void *)result;
57980   return jresult;
57981 }
57982
57983
57984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57985   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57986
57987   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57988   {
57989     try {
57990       delete arg1;
57991     } catch (std::out_of_range& e) {
57992       {
57993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57994       };
57995     } catch (std::exception& e) {
57996       {
57997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57998       };
57999     } catch (Dali::DaliException e) {
58000       {
58001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58002       };
58003     } catch (...) {
58004       {
58005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58006       };
58007     }
58008   }
58009
58010 }
58011
58012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58013   unsigned int jresult ;
58014   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58015   bool result = false;
58016
58017   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58018   {
58019     try {
58020       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);
58021     } catch (std::out_of_range& e) {
58022       {
58023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58024       };
58025     } catch (std::exception& e) {
58026       {
58027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58028       };
58029     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58030   }
58031   jresult = result;
58032   return jresult;
58033 }
58034
58035 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58036   unsigned long jresult ;
58037   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58038   std::size_t result = 0;
58039
58040   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58041   {
58042     try {
58043       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);
58044     } catch (std::out_of_range& e) {
58045       {
58046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58047       };
58048     } catch (std::exception& e) {
58049       {
58050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58051       };
58052     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58053   }
58054   jresult = (unsigned long)result;
58055   return jresult;
58056 }
58057
58058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58059   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58060   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58061
58062   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58063   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58064   {
58065     try {
58066       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58067     } catch (std::out_of_range& e) {
58068       {
58069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58070       };
58071     } catch (std::exception& e) {
58072       {
58073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58074       };
58075     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58076   }
58077 }
58078
58079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58080   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58081   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58082
58083   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58084   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58085   {
58086     try {
58087       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58088     } catch (std::out_of_range& e) {
58089       {
58090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58091       };
58092     } catch (std::exception& e) {
58093       {
58094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58095       };
58096     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58097   }
58098 }
58099
58100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58101   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58102   Dali::Actor arg2 ;
58103   //bool arg3 ;
58104   Dali::LayoutDirection::Type arg4 ;
58105   Dali::Actor *argp2 ;
58106
58107   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58108   argp2 = (Dali::Actor *)jarg2;
58109   if (!argp2) {
58110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58111     return ;
58112   }
58113   arg2 = *argp2;
58114   //arg3 = jarg3 ? true : false;
58115   arg4 = (Dali::LayoutDirection::Type)jarg4;
58116   {
58117     try {
58118       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58119     } catch (std::out_of_range& e) {
58120       {
58121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58122       };
58123     } catch (std::exception& e) {
58124       {
58125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58126       };
58127     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58128   }
58129 }
58130
58131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58132   void * jresult ;
58133   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58134
58135   {
58136     try {
58137       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58138     } catch (std::out_of_range& e) {
58139       {
58140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58141       };
58142     } catch (std::exception& e) {
58143       {
58144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58145       };
58146     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58147   }
58148   jresult = (void *)result;
58149   return jresult;
58150 }
58151
58152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58153   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58154
58155   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58156   {
58157     try {
58158       delete arg1;
58159     } catch (std::out_of_range& e) {
58160       {
58161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58162       };
58163     } catch (std::exception& e) {
58164       {
58165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58166       };
58167     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58168   }
58169 }
58170
58171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58172   unsigned int jresult ;
58173   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58174   bool result;
58175
58176   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58177   {
58178     try {
58179       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);
58180     } catch (std::out_of_range& e) {
58181       {
58182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58183       };
58184     } catch (std::exception& e) {
58185       {
58186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58187       };
58188     } catch (Dali::DaliException e) {
58189       {
58190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58191       };
58192     } catch (...) {
58193       {
58194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58195       };
58196     }
58197   }
58198
58199   jresult = result;
58200   return jresult;
58201 }
58202
58203
58204 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58205   unsigned long jresult ;
58206   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58207   std::size_t result;
58208
58209   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58210   {
58211     try {
58212       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);
58213     } catch (std::out_of_range& e) {
58214       {
58215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58216       };
58217     } catch (std::exception& e) {
58218       {
58219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58220       };
58221     } catch (Dali::DaliException e) {
58222       {
58223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58224       };
58225     } catch (...) {
58226       {
58227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58228       };
58229     }
58230   }
58231
58232   jresult = (unsigned long)result;
58233   return jresult;
58234 }
58235
58236
58237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58238   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58239   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58240
58241   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58242   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58243   {
58244     try {
58245       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58246     } catch (std::out_of_range& e) {
58247       {
58248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58249       };
58250     } catch (std::exception& e) {
58251       {
58252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58253       };
58254     } catch (Dali::DaliException e) {
58255       {
58256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58257       };
58258     } catch (...) {
58259       {
58260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58261       };
58262     }
58263   }
58264
58265 }
58266
58267
58268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58269   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58270   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58271
58272   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58273   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58274   {
58275     try {
58276       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58277     } catch (std::out_of_range& e) {
58278       {
58279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58280       };
58281     } catch (std::exception& e) {
58282       {
58283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58284       };
58285     } catch (Dali::DaliException e) {
58286       {
58287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58288       };
58289     } catch (...) {
58290       {
58291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58292       };
58293     }
58294   }
58295
58296 }
58297
58298
58299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58300   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58301   Dali::Actor arg2 ;
58302   bool arg3 ;
58303   Dali::DevelActor::VisibilityChange::Type arg4 ;
58304   Dali::Actor *argp2 ;
58305
58306   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58307   argp2 = (Dali::Actor *)jarg2;
58308   if (!argp2) {
58309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58310     return ;
58311   }
58312   arg2 = *argp2;
58313   arg3 = jarg3 ? true : false;
58314   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58315   {
58316     try {
58317       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58318     } catch (std::out_of_range& e) {
58319       {
58320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58321       };
58322     } catch (std::exception& e) {
58323       {
58324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58325       };
58326     } catch (Dali::DaliException e) {
58327       {
58328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58329       };
58330     } catch (...) {
58331       {
58332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58333       };
58334     }
58335   }
58336
58337 }
58338
58339
58340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58341   void * jresult ;
58342   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58343
58344   {
58345     try {
58346       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58347     } catch (std::out_of_range& e) {
58348       {
58349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58350       };
58351     } catch (std::exception& e) {
58352       {
58353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58354       };
58355     } catch (Dali::DaliException e) {
58356       {
58357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58358       };
58359     } catch (...) {
58360       {
58361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58362       };
58363     }
58364   }
58365
58366   jresult = (void *)result;
58367   return jresult;
58368 }
58369
58370
58371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58372   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58373
58374   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58375   {
58376     try {
58377       delete arg1;
58378     } catch (std::out_of_range& e) {
58379       {
58380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58381       };
58382     } catch (std::exception& e) {
58383       {
58384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58385       };
58386     } catch (Dali::DaliException e) {
58387       {
58388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58389       };
58390     } catch (...) {
58391       {
58392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58393       };
58394     }
58395   }
58396
58397 }
58398
58399
58400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58401   void * jresult ;
58402   Dali::Timer *result = 0 ;
58403
58404   {
58405     try {
58406       result = (Dali::Timer *)new Dali::Timer();
58407     } catch (std::out_of_range& e) {
58408       {
58409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58410       };
58411     } catch (std::exception& e) {
58412       {
58413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58414       };
58415     } catch (Dali::DaliException e) {
58416       {
58417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58418       };
58419     } catch (...) {
58420       {
58421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58422       };
58423     }
58424   }
58425
58426   jresult = (void *)result;
58427   return jresult;
58428 }
58429
58430
58431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58432   void * jresult ;
58433   unsigned int arg1 ;
58434   Dali::Timer result;
58435
58436   arg1 = (unsigned int)jarg1;
58437   {
58438     try {
58439       result = Dali::Timer::New(arg1);
58440     } catch (std::out_of_range& e) {
58441       {
58442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58443       };
58444     } catch (std::exception& e) {
58445       {
58446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58447       };
58448     } catch (Dali::DaliException e) {
58449       {
58450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58451       };
58452     } catch (...) {
58453       {
58454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58455       };
58456     }
58457   }
58458
58459   jresult = new Dali::Timer((const Dali::Timer &)result);
58460   return jresult;
58461 }
58462
58463
58464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58465   void * jresult ;
58466   Dali::Timer *arg1 = 0 ;
58467   Dali::Timer *result = 0 ;
58468
58469   arg1 = (Dali::Timer *)jarg1;
58470   if (!arg1) {
58471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58472     return 0;
58473   }
58474   {
58475     try {
58476       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58477     } catch (std::out_of_range& e) {
58478       {
58479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58480       };
58481     } catch (std::exception& e) {
58482       {
58483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58484       };
58485     } catch (Dali::DaliException e) {
58486       {
58487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58488       };
58489     } catch (...) {
58490       {
58491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58492       };
58493     }
58494   }
58495
58496   jresult = (void *)result;
58497   return jresult;
58498 }
58499
58500
58501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58502   void * jresult ;
58503   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58504   Dali::Timer *arg2 = 0 ;
58505   Dali::Timer *result = 0 ;
58506
58507   arg1 = (Dali::Timer *)jarg1;
58508   arg2 = (Dali::Timer *)jarg2;
58509   if (!arg2) {
58510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58511     return 0;
58512   }
58513   {
58514     try {
58515       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58516     } catch (std::out_of_range& e) {
58517       {
58518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58519       };
58520     } catch (std::exception& e) {
58521       {
58522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58523       };
58524     } catch (Dali::DaliException e) {
58525       {
58526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58527       };
58528     } catch (...) {
58529       {
58530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58531       };
58532     }
58533   }
58534
58535   jresult = (void *)result;
58536   return jresult;
58537 }
58538
58539
58540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58541   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58542
58543   arg1 = (Dali::Timer *)jarg1;
58544   {
58545     try {
58546       delete arg1;
58547     } catch (std::out_of_range& e) {
58548       {
58549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58550       };
58551     } catch (std::exception& e) {
58552       {
58553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58554       };
58555     } catch (Dali::DaliException e) {
58556       {
58557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58558       };
58559     } catch (...) {
58560       {
58561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58562       };
58563     }
58564   }
58565
58566 }
58567
58568
58569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58570   void * jresult ;
58571   Dali::BaseHandle arg1 ;
58572   Dali::BaseHandle *argp1 ;
58573   Dali::Timer result;
58574
58575   argp1 = (Dali::BaseHandle *)jarg1;
58576   if (!argp1) {
58577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58578     return 0;
58579   }
58580   arg1 = *argp1;
58581   {
58582     try {
58583       result = Dali::Timer::DownCast(arg1);
58584     } catch (std::out_of_range& e) {
58585       {
58586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58587       };
58588     } catch (std::exception& e) {
58589       {
58590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58591       };
58592     } catch (Dali::DaliException e) {
58593       {
58594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58595       };
58596     } catch (...) {
58597       {
58598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58599       };
58600     }
58601   }
58602
58603   jresult = new Dali::Timer((const Dali::Timer &)result);
58604   return jresult;
58605 }
58606
58607
58608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58609   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58610
58611   arg1 = (Dali::Timer *)jarg1;
58612   {
58613     try {
58614       (arg1)->Start();
58615     } catch (std::out_of_range& e) {
58616       {
58617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58618       };
58619     } catch (std::exception& e) {
58620       {
58621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58622       };
58623     } catch (Dali::DaliException e) {
58624       {
58625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58626       };
58627     } catch (...) {
58628       {
58629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58630       };
58631     }
58632   }
58633
58634 }
58635
58636
58637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58638   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58639
58640   arg1 = (Dali::Timer *)jarg1;
58641   {
58642     try {
58643       (arg1)->Stop();
58644     } catch (std::out_of_range& e) {
58645       {
58646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58647       };
58648     } catch (std::exception& e) {
58649       {
58650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58651       };
58652     } catch (Dali::DaliException e) {
58653       {
58654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58655       };
58656     } catch (...) {
58657       {
58658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58659       };
58660     }
58661   }
58662
58663 }
58664
58665
58666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58667   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58668   unsigned int arg2 ;
58669
58670   arg1 = (Dali::Timer *)jarg1;
58671   arg2 = (unsigned int)jarg2;
58672   {
58673     try {
58674       (arg1)->SetInterval(arg2);
58675     } catch (std::out_of_range& e) {
58676       {
58677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58678       };
58679     } catch (std::exception& e) {
58680       {
58681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58682       };
58683     } catch (Dali::DaliException e) {
58684       {
58685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58686       };
58687     } catch (...) {
58688       {
58689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58690       };
58691     }
58692   }
58693
58694 }
58695
58696
58697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58698   unsigned int jresult ;
58699   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58700   unsigned int result;
58701
58702   arg1 = (Dali::Timer *)jarg1;
58703   {
58704     try {
58705       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58706     } catch (std::out_of_range& e) {
58707       {
58708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58709       };
58710     } catch (std::exception& e) {
58711       {
58712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58713       };
58714     } catch (Dali::DaliException e) {
58715       {
58716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58717       };
58718     } catch (...) {
58719       {
58720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58721       };
58722     }
58723   }
58724
58725   jresult = result;
58726   return jresult;
58727 }
58728
58729
58730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58731   unsigned int jresult ;
58732   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58733   bool result;
58734
58735   arg1 = (Dali::Timer *)jarg1;
58736   {
58737     try {
58738       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58739     } catch (std::out_of_range& e) {
58740       {
58741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58742       };
58743     } catch (std::exception& e) {
58744       {
58745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58746       };
58747     } catch (Dali::DaliException e) {
58748       {
58749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58750       };
58751     } catch (...) {
58752       {
58753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58754       };
58755     }
58756   }
58757
58758   jresult = result;
58759   return jresult;
58760 }
58761
58762
58763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58764   void * jresult ;
58765   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58766   Dali::Timer::TimerSignalType *result = 0 ;
58767
58768   arg1 = (Dali::Timer *)jarg1;
58769   {
58770     try {
58771       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58772     } catch (std::out_of_range& e) {
58773       {
58774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58775       };
58776     } catch (std::exception& e) {
58777       {
58778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58779       };
58780     } catch (Dali::DaliException e) {
58781       {
58782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58783       };
58784     } catch (...) {
58785       {
58786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58787       };
58788     }
58789   }
58790
58791   jresult = (void *)result;
58792   return jresult;
58793 }
58794
58795
58796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58797   unsigned int jresult ;
58798   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58799   bool result;
58800
58801   arg1 = (Dali::Signal< bool () > *)jarg1;
58802   {
58803     try {
58804       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58805     } catch (std::out_of_range& e) {
58806       {
58807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58808       };
58809     } catch (std::exception& e) {
58810       {
58811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58812       };
58813     } catch (Dali::DaliException e) {
58814       {
58815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58816       };
58817     } catch (...) {
58818       {
58819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58820       };
58821     }
58822   }
58823
58824   jresult = result;
58825   return jresult;
58826 }
58827
58828
58829 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58830   unsigned long jresult ;
58831   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58832   std::size_t result;
58833
58834   arg1 = (Dali::Signal< bool () > *)jarg1;
58835   {
58836     try {
58837       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58838     } catch (std::out_of_range& e) {
58839       {
58840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58841       };
58842     } catch (std::exception& e) {
58843       {
58844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58845       };
58846     } catch (Dali::DaliException e) {
58847       {
58848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58849       };
58850     } catch (...) {
58851       {
58852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58853       };
58854     }
58855   }
58856
58857   jresult = (unsigned long)result;
58858   return jresult;
58859 }
58860
58861
58862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58863   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58864   bool (*arg2)() = (bool (*)()) 0 ;
58865
58866   arg1 = (Dali::Signal< bool () > *)jarg1;
58867   arg2 = (bool (*)())jarg2;
58868   {
58869     try {
58870       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58871     } catch (std::out_of_range& e) {
58872       {
58873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58874       };
58875     } catch (std::exception& e) {
58876       {
58877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58878       };
58879     } catch (Dali::DaliException e) {
58880       {
58881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58882       };
58883     } catch (...) {
58884       {
58885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58886       };
58887     }
58888   }
58889
58890 }
58891
58892
58893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
58894   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58895   bool (*arg2)() = (bool (*)()) 0 ;
58896
58897   arg1 = (Dali::Signal< bool () > *)jarg1;
58898   arg2 = (bool (*)())jarg2;
58899   {
58900     try {
58901       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
58902     } catch (std::out_of_range& e) {
58903       {
58904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58905       };
58906     } catch (std::exception& e) {
58907       {
58908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58909       };
58910     } catch (Dali::DaliException e) {
58911       {
58912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58913       };
58914     } catch (...) {
58915       {
58916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58917       };
58918     }
58919   }
58920
58921 }
58922
58923
58924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
58925   unsigned int jresult ;
58926   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58927   bool result;
58928
58929   arg1 = (Dali::Signal< bool () > *)jarg1;
58930   {
58931     try {
58932       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
58933     } catch (std::out_of_range& e) {
58934       {
58935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58936       };
58937     } catch (std::exception& e) {
58938       {
58939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58940       };
58941     } catch (Dali::DaliException e) {
58942       {
58943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58944       };
58945     } catch (...) {
58946       {
58947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58948       };
58949     }
58950   }
58951
58952   jresult = result;
58953   return jresult;
58954 }
58955
58956
58957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
58958   void * jresult ;
58959   Dali::Signal< bool () > *result = 0 ;
58960
58961   {
58962     try {
58963       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
58964     } catch (std::out_of_range& e) {
58965       {
58966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58967       };
58968     } catch (std::exception& e) {
58969       {
58970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58971       };
58972     } catch (Dali::DaliException e) {
58973       {
58974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58975       };
58976     } catch (...) {
58977       {
58978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58979       };
58980     }
58981   }
58982
58983   jresult = (void *)result;
58984   return jresult;
58985 }
58986
58987
58988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
58989   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58990
58991   arg1 = (Dali::Signal< bool () > *)jarg1;
58992   {
58993     try {
58994       delete arg1;
58995     } catch (std::out_of_range& e) {
58996       {
58997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58998       };
58999     } catch (std::exception& e) {
59000       {
59001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59002       };
59003     } catch (Dali::DaliException e) {
59004       {
59005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59006       };
59007     } catch (...) {
59008       {
59009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59010       };
59011     }
59012   }
59013
59014 }
59015
59016
59017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59018   int jresult ;
59019   int result;
59020
59021   {
59022     try {
59023       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59024     } catch (std::out_of_range& e) {
59025       {
59026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59027       };
59028     } catch (std::exception& e) {
59029       {
59030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59031       };
59032     } catch (Dali::DaliException e) {
59033       {
59034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59035       };
59036     } catch (...) {
59037       {
59038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59039       };
59040     }
59041   }
59042
59043   jresult = (int)result;
59044   return jresult;
59045 }
59046
59047
59048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59049   int jresult ;
59050   int result;
59051
59052   {
59053     try {
59054       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59055     } catch (std::out_of_range& e) {
59056       {
59057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59058       };
59059     } catch (std::exception& e) {
59060       {
59061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59062       };
59063     } catch (Dali::DaliException e) {
59064       {
59065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59066       };
59067     } catch (...) {
59068       {
59069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59070       };
59071     }
59072   }
59073
59074   jresult = (int)result;
59075   return jresult;
59076 }
59077
59078
59079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59080   int jresult ;
59081   int result;
59082
59083   {
59084     try {
59085       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59086     } catch (std::out_of_range& e) {
59087       {
59088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59089       };
59090     } catch (std::exception& e) {
59091       {
59092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59093       };
59094     } catch (Dali::DaliException e) {
59095       {
59096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59097       };
59098     } catch (...) {
59099       {
59100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59101       };
59102     }
59103   }
59104
59105   jresult = (int)result;
59106   return jresult;
59107 }
59108
59109
59110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59111   int jresult ;
59112   int result;
59113
59114   {
59115     try {
59116       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59117     } catch (std::out_of_range& e) {
59118       {
59119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59120       };
59121     } catch (std::exception& e) {
59122       {
59123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59124       };
59125     } catch (Dali::DaliException e) {
59126       {
59127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59128       };
59129     } catch (...) {
59130       {
59131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59132       };
59133     }
59134   }
59135
59136   jresult = (int)result;
59137   return jresult;
59138 }
59139
59140
59141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59142   int jresult ;
59143   int result;
59144
59145   {
59146     try {
59147       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59148     } catch (std::out_of_range& e) {
59149       {
59150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59151       };
59152     } catch (std::exception& e) {
59153       {
59154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59155       };
59156     } catch (Dali::DaliException e) {
59157       {
59158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59159       };
59160     } catch (...) {
59161       {
59162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59163       };
59164     }
59165   }
59166
59167   jresult = (int)result;
59168   return jresult;
59169 }
59170
59171
59172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59173   int jresult ;
59174   int result;
59175
59176   {
59177     try {
59178       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59179     } catch (std::out_of_range& e) {
59180       {
59181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59182       };
59183     } catch (std::exception& e) {
59184       {
59185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59186       };
59187     } catch (Dali::DaliException e) {
59188       {
59189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59190       };
59191     } catch (...) {
59192       {
59193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59194       };
59195     }
59196   }
59197
59198   jresult = (int)result;
59199   return jresult;
59200 }
59201
59202
59203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59204   int jresult ;
59205   int result;
59206
59207   {
59208     try {
59209       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59210     } catch (std::out_of_range& e) {
59211       {
59212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59213       };
59214     } catch (std::exception& e) {
59215       {
59216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59217       };
59218     } catch (Dali::DaliException e) {
59219       {
59220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59221       };
59222     } catch (...) {
59223       {
59224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59225       };
59226     }
59227   }
59228
59229   jresult = (int)result;
59230   return jresult;
59231 }
59232
59233
59234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59235   int jresult ;
59236   int result;
59237
59238   {
59239     try {
59240       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59241     } catch (std::out_of_range& e) {
59242       {
59243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59244       };
59245     } catch (std::exception& e) {
59246       {
59247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59248       };
59249     } catch (Dali::DaliException e) {
59250       {
59251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59252       };
59253     } catch (...) {
59254       {
59255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59256       };
59257     }
59258   }
59259
59260   jresult = (int)result;
59261   return jresult;
59262 }
59263
59264
59265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59266   int jresult ;
59267   int result;
59268
59269   {
59270     try {
59271       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59272     } catch (std::out_of_range& e) {
59273       {
59274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59275       };
59276     } catch (std::exception& e) {
59277       {
59278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59279       };
59280     } catch (Dali::DaliException e) {
59281       {
59282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59283       };
59284     } catch (...) {
59285       {
59286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59287       };
59288     }
59289   }
59290
59291   jresult = (int)result;
59292   return jresult;
59293 }
59294
59295
59296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59297   int jresult ;
59298   int result;
59299
59300   {
59301     try {
59302       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59303     } catch (std::out_of_range& e) {
59304       {
59305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59306       };
59307     } catch (std::exception& e) {
59308       {
59309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59310       };
59311     } catch (Dali::DaliException e) {
59312       {
59313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59314       };
59315     } catch (...) {
59316       {
59317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59318       };
59319     }
59320   }
59321
59322   jresult = (int)result;
59323   return jresult;
59324 }
59325
59326
59327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59328   int jresult ;
59329   int result;
59330
59331   {
59332     try {
59333       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59334     } catch (std::out_of_range& e) {
59335       {
59336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59337       };
59338     } catch (std::exception& e) {
59339       {
59340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59341       };
59342     } catch (Dali::DaliException e) {
59343       {
59344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59345       };
59346     } catch (...) {
59347       {
59348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59349       };
59350     }
59351   }
59352
59353   jresult = (int)result;
59354   return jresult;
59355 }
59356
59357
59358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59359   int jresult ;
59360   int result;
59361
59362   {
59363     try {
59364       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59365     } catch (std::out_of_range& e) {
59366       {
59367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59368       };
59369     } catch (std::exception& e) {
59370       {
59371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59372       };
59373     } catch (Dali::DaliException e) {
59374       {
59375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59376       };
59377     } catch (...) {
59378       {
59379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59380       };
59381     }
59382   }
59383
59384   jresult = (int)result;
59385   return jresult;
59386 }
59387
59388
59389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59390   int jresult ;
59391   int result;
59392
59393   {
59394     try {
59395       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59396     } catch (std::out_of_range& e) {
59397       {
59398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59399       };
59400     } catch (std::exception& e) {
59401       {
59402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59403       };
59404     } catch (Dali::DaliException e) {
59405       {
59406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59407       };
59408     } catch (...) {
59409       {
59410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59411       };
59412     }
59413   }
59414
59415   jresult = (int)result;
59416   return jresult;
59417 }
59418
59419
59420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59421   int jresult ;
59422   int result;
59423
59424   {
59425     try {
59426       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59427     } catch (std::out_of_range& e) {
59428       {
59429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59430       };
59431     } catch (std::exception& e) {
59432       {
59433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59434       };
59435     } catch (Dali::DaliException e) {
59436       {
59437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59438       };
59439     } catch (...) {
59440       {
59441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59442       };
59443     }
59444   }
59445
59446   jresult = (int)result;
59447   return jresult;
59448 }
59449
59450
59451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59452   int jresult ;
59453   int result;
59454
59455   {
59456     try {
59457       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59458     } catch (std::out_of_range& e) {
59459       {
59460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59461       };
59462     } catch (std::exception& e) {
59463       {
59464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59465       };
59466     } catch (Dali::DaliException e) {
59467       {
59468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59469       };
59470     } catch (...) {
59471       {
59472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59473       };
59474     }
59475   }
59476
59477   jresult = (int)result;
59478   return jresult;
59479 }
59480
59481
59482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59483   int jresult ;
59484   int result;
59485
59486   {
59487     try {
59488       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59489     } catch (std::out_of_range& e) {
59490       {
59491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59492       };
59493     } catch (std::exception& e) {
59494       {
59495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59496       };
59497     } catch (Dali::DaliException e) {
59498       {
59499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59500       };
59501     } catch (...) {
59502       {
59503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59504       };
59505     }
59506   }
59507
59508   jresult = (int)result;
59509   return jresult;
59510 }
59511
59512
59513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59514   int jresult ;
59515   int result;
59516
59517   {
59518     try {
59519       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59520     } catch (std::out_of_range& e) {
59521       {
59522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59523       };
59524     } catch (std::exception& e) {
59525       {
59526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59527       };
59528     } catch (Dali::DaliException e) {
59529       {
59530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59531       };
59532     } catch (...) {
59533       {
59534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59535       };
59536     }
59537   }
59538
59539   jresult = (int)result;
59540   return jresult;
59541 }
59542
59543
59544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59545   int jresult ;
59546   int result;
59547
59548   {
59549     try {
59550       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59551     } catch (std::out_of_range& e) {
59552       {
59553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59554       };
59555     } catch (std::exception& e) {
59556       {
59557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59558       };
59559     } catch (Dali::DaliException e) {
59560       {
59561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59562       };
59563     } catch (...) {
59564       {
59565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59566       };
59567     }
59568   }
59569
59570   jresult = (int)result;
59571   return jresult;
59572 }
59573
59574
59575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59576   int jresult ;
59577   int result;
59578
59579   {
59580     try {
59581       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59582     } catch (std::out_of_range& e) {
59583       {
59584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59585       };
59586     } catch (std::exception& e) {
59587       {
59588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59589       };
59590     } catch (Dali::DaliException e) {
59591       {
59592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59593       };
59594     } catch (...) {
59595       {
59596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59597       };
59598     }
59599   }
59600
59601   jresult = (int)result;
59602   return jresult;
59603 }
59604
59605
59606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59607   int jresult ;
59608   int result;
59609
59610   {
59611     try {
59612       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59613     } catch (std::out_of_range& e) {
59614       {
59615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59616       };
59617     } catch (std::exception& e) {
59618       {
59619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59620       };
59621     } catch (Dali::DaliException e) {
59622       {
59623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59624       };
59625     } catch (...) {
59626       {
59627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59628       };
59629     }
59630   }
59631
59632   jresult = (int)result;
59633   return jresult;
59634 }
59635
59636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59637   int jresult ;
59638   int result;
59639
59640   {
59641     try {
59642       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59643     } catch (std::out_of_range& e) {
59644       {
59645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59646       };
59647     } catch (std::exception& e) {
59648       {
59649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59650       };
59651     } catch (Dali::DaliException e) {
59652       {
59653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59654       };
59655     } catch (...) {
59656       {
59657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59658       };
59659     }
59660   }
59661
59662   jresult = (int)result;
59663   return jresult;
59664 }
59665
59666
59667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59668   int jresult ;
59669   int result;
59670   {
59671     try
59672     {
59673       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59674     } catch (std::out_of_range& e) {
59675       {
59676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59677       };
59678     } catch (std::exception& e) {
59679       {
59680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59681       };
59682     } catch (Dali::DaliException e) {
59683       {
59684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59685       };
59686     } catch (...) {
59687       {
59688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59689       };
59690     }
59691   }
59692
59693   jresult = (int)result;
59694   return jresult;
59695 }
59696
59697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59698   int jresult ;
59699   int result;
59700   {
59701     try
59702     {
59703       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59704     } catch (std::out_of_range& e) {
59705       {
59706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59707       };
59708     } catch (std::exception& e) {
59709       {
59710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59711       };
59712     } catch (Dali::DaliException e) {
59713       {
59714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59715       };
59716     } catch (...) {
59717       {
59718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59719       };
59720     }
59721   }
59722
59723   jresult = (int)result;
59724   return jresult;
59725 }
59726
59727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59728   int jresult ;
59729   int result;
59730   {
59731     try
59732     {
59733       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59734     } catch (std::out_of_range& e) {
59735       {
59736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59737       };
59738     } catch (std::exception& e) {
59739       {
59740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59741       };
59742     } catch (Dali::DaliException e) {
59743       {
59744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59745       };
59746     } catch (...) {
59747       {
59748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59749       };
59750     }
59751   }
59752
59753   jresult = (int)result;
59754   return jresult;
59755 }
59756
59757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59758   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59759 }
59760
59761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59762   int jresult ;
59763   int result;
59764   {
59765     try
59766     {
59767       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59768     } catch (std::out_of_range& e) {
59769       {
59770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59771       };
59772     } catch (std::exception& e) {
59773       {
59774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59775       };
59776     } catch (Dali::DaliException e) {
59777       {
59778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59779       };
59780     } catch (...) {
59781       {
59782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59783       };
59784     }
59785   }
59786
59787   jresult = (int)result;
59788   return jresult;
59789 }
59790
59791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59792   int jresult ;
59793   int result;
59794   {
59795     try
59796     {
59797       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59798     } catch (std::out_of_range& e) {
59799       {
59800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59801       };
59802     } catch (std::exception& e) {
59803       {
59804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59805       };
59806     } catch (Dali::DaliException e) {
59807       {
59808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59809       };
59810     } catch (...) {
59811       {
59812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59813       };
59814     }
59815   }
59816
59817   jresult = (int)result;
59818   return jresult;
59819 }
59820
59821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59822   int jresult ;
59823   int result;
59824
59825   {
59826     try {
59827       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59828     } catch (std::out_of_range& e) {
59829       {
59830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59831       };
59832     } catch (std::exception& e) {
59833       {
59834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59835       };
59836     } catch (Dali::DaliException e) {
59837       {
59838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59839       };
59840     } catch (...) {
59841       {
59842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59843       };
59844     }
59845   }
59846
59847   jresult = (int)result;
59848   return jresult;
59849 }
59850
59851
59852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59853   int jresult ;
59854   int result;
59855
59856   {
59857     try {
59858       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59859     } catch (std::out_of_range& e) {
59860       {
59861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59862       };
59863     } catch (std::exception& e) {
59864       {
59865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59866       };
59867     } catch (Dali::DaliException e) {
59868       {
59869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59870       };
59871     } catch (...) {
59872       {
59873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59874       };
59875     }
59876   }
59877
59878   jresult = (int)result;
59879   return jresult;
59880 }
59881
59882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59883   int jresult ;
59884   int result;
59885   {
59886     try
59887     {
59888       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
59889     } catch (std::out_of_range& e) {
59890       {
59891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59892       };
59893     } catch (std::exception& e) {
59894       {
59895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59896       };
59897     } catch (...) {
59898       {
59899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59900       };
59901     }
59902   }
59903   jresult = (int)result;
59904   return jresult;
59905 }
59906
59907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
59908   int jresult ;
59909   int result;
59910   {
59911     try
59912     {
59913       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
59914     } catch (std::out_of_range& e) {
59915       {
59916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59917       };
59918     } catch (std::exception& e) {
59919       {
59920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59921       };
59922     } catch (...) {
59923       {
59924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59925       };
59926     }
59927   }
59928   jresult = (int)result;
59929   return jresult;
59930 }
59931
59932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
59933   int jresult ;
59934   int result;
59935   {
59936     try
59937     {
59938       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
59939     } catch (std::out_of_range& e) {
59940       {
59941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59942       };
59943     } catch (std::exception& e) {
59944       {
59945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59946       };
59947     } catch (...) {
59948       {
59949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59950       };
59951     }
59952   }
59953   jresult = (int)result;
59954   return jresult;
59955 }
59956
59957
59958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
59959   int jresult ;
59960   int result;
59961   {
59962     try
59963     {
59964       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
59965     } catch (std::out_of_range& e) {
59966       {
59967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59968       };
59969     } catch (std::exception& e) {
59970       {
59971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59972       };
59973     } catch (...) {
59974       {
59975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59976       };
59977     }
59978   }
59979   jresult = (int)result;
59980   return jresult;
59981 }
59982
59983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
59984   int jresult ;
59985   int result;
59986   {
59987     try
59988     {
59989       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
59990     } catch (std::out_of_range& e) {
59991       {
59992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59993       };
59994     } catch (std::exception& e) {
59995       {
59996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59997       };
59998     } catch (...) {
59999       {
60000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60001       };
60002     }
60003   }
60004   jresult = (int)result;
60005   return jresult;
60006 }
60007
60008
60009
60010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60011   int jresult ;
60012   int result;
60013
60014   {
60015     try {
60016       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60017     } catch (std::out_of_range& e) {
60018       {
60019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60020       };
60021     } catch (std::exception& e) {
60022       {
60023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60024       };
60025     } catch (Dali::DaliException e) {
60026       {
60027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60028       };
60029     } catch (...) {
60030       {
60031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60032       };
60033     }
60034   }
60035
60036   jresult = (int)result;
60037   return jresult;
60038 }
60039
60040
60041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60042   int jresult ;
60043   int result;
60044
60045   {
60046     try {
60047       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60048     } catch (std::out_of_range& e) {
60049       {
60050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60051       };
60052     } catch (std::exception& e) {
60053       {
60054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60055       };
60056     } catch (Dali::DaliException e) {
60057       {
60058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60059       };
60060     } catch (...) {
60061       {
60062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60063       };
60064     }
60065   }
60066
60067   jresult = (int)result;
60068   return jresult;
60069 }
60070
60071
60072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60073   int jresult ;
60074   int result;
60075
60076   {
60077     try {
60078       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60079     } catch (std::out_of_range& e) {
60080       {
60081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60082       };
60083     } catch (std::exception& e) {
60084       {
60085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60086       };
60087     } catch (Dali::DaliException e) {
60088       {
60089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60090       };
60091     } catch (...) {
60092       {
60093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60094       };
60095     }
60096   }
60097
60098   jresult = (int)result;
60099   return jresult;
60100 }
60101
60102
60103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60104   int jresult ;
60105   int result;
60106
60107   {
60108     try {
60109       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60110     } catch (std::out_of_range& e) {
60111       {
60112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60113       };
60114     } catch (std::exception& e) {
60115       {
60116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60117       };
60118     } catch (Dali::DaliException e) {
60119       {
60120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60121       };
60122     } catch (...) {
60123       {
60124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60125       };
60126     }
60127   }
60128
60129   jresult = (int)result;
60130   return jresult;
60131 }
60132
60133
60134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60135   int jresult ;
60136   int result;
60137
60138   {
60139     try {
60140       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60141     } catch (std::out_of_range& e) {
60142       {
60143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60144       };
60145     } catch (std::exception& e) {
60146       {
60147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60148       };
60149     } catch (Dali::DaliException e) {
60150       {
60151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60152       };
60153     } catch (...) {
60154       {
60155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60156       };
60157     }
60158   }
60159
60160   jresult = (int)result;
60161   return jresult;
60162 }
60163
60164
60165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60166   int jresult ;
60167   int result;
60168
60169   {
60170     try {
60171       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60172     } catch (std::out_of_range& e) {
60173       {
60174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60175       };
60176     } catch (std::exception& e) {
60177       {
60178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60179       };
60180     } catch (Dali::DaliException e) {
60181       {
60182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60183       };
60184     } catch (...) {
60185       {
60186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60187       };
60188     }
60189   }
60190
60191   jresult = (int)result;
60192   return jresult;
60193 }
60194
60195
60196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60197   int jresult ;
60198   int result;
60199
60200   {
60201     try {
60202       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60203     } catch (std::out_of_range& e) {
60204       {
60205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60206       };
60207     } catch (std::exception& e) {
60208       {
60209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60210       };
60211     } catch (Dali::DaliException e) {
60212       {
60213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60214       };
60215     } catch (...) {
60216       {
60217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60218       };
60219     }
60220   }
60221
60222   jresult = (int)result;
60223   return jresult;
60224 }
60225
60226 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60227   int jresult ;
60228   int result;
60229
60230   {
60231     try {
60232       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60233     } catch (std::out_of_range& e) {
60234       {
60235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60236       };
60237     } catch (std::exception& e) {
60238       {
60239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60240       };
60241     } catch (...) {
60242       {
60243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60244       };
60245     }
60246   }
60247   jresult = (int)result;
60248   return jresult;
60249 }
60250
60251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60252   int jresult ;
60253   int result;
60254
60255   {
60256     try {
60257       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60258     } catch (std::out_of_range& e) {
60259       {
60260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60261       };
60262     } catch (std::exception& e) {
60263       {
60264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60265       };
60266     } catch (Dali::DaliException e) {
60267       {
60268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60269       };
60270     } catch (...) {
60271       {
60272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60273       };
60274     }
60275   }
60276
60277   jresult = (int)result;
60278   return jresult;
60279 }
60280
60281
60282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60283   int jresult ;
60284   int result;
60285
60286   {
60287     try {
60288       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60289     } catch (std::out_of_range& e) {
60290       {
60291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60292       };
60293     } catch (std::exception& e) {
60294       {
60295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60296       };
60297     } catch (Dali::DaliException e) {
60298       {
60299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60300       };
60301     } catch (...) {
60302       {
60303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60304       };
60305     }
60306   }
60307
60308   jresult = (int)result;
60309   return jresult;
60310 }
60311
60312
60313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60314   int jresult ;
60315   int result;
60316
60317   {
60318     try {
60319       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60320     } catch (std::out_of_range& e) {
60321       {
60322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60323       };
60324     } catch (std::exception& e) {
60325       {
60326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60327       };
60328     } catch (Dali::DaliException e) {
60329       {
60330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60331       };
60332     } catch (...) {
60333       {
60334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60335       };
60336     }
60337   }
60338
60339   jresult = (int)result;
60340   return jresult;
60341 }
60342
60343
60344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60345   int jresult ;
60346   int result;
60347
60348   {
60349     try {
60350       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60351     } catch (std::out_of_range& e) {
60352       {
60353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60354       };
60355     } catch (std::exception& e) {
60356       {
60357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60358       };
60359     } catch (Dali::DaliException e) {
60360       {
60361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60362       };
60363     } catch (...) {
60364       {
60365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60366       };
60367     }
60368   }
60369
60370   jresult = (int)result;
60371   return jresult;
60372 }
60373
60374
60375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60376   int jresult ;
60377   int result;
60378
60379   {
60380     try {
60381       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60382     } catch (std::out_of_range& e) {
60383       {
60384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60385       };
60386     } catch (std::exception& e) {
60387       {
60388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60389       };
60390     } catch (Dali::DaliException e) {
60391       {
60392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60393       };
60394     } catch (...) {
60395       {
60396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60397       };
60398     }
60399   }
60400
60401   jresult = (int)result;
60402   return jresult;
60403 }
60404
60405
60406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60407   int jresult ;
60408   int result;
60409
60410   {
60411     try {
60412       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60413     } catch (std::out_of_range& e) {
60414       {
60415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60416       };
60417     } catch (std::exception& e) {
60418       {
60419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60420       };
60421     } catch (Dali::DaliException e) {
60422       {
60423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60424       };
60425     } catch (...) {
60426       {
60427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60428       };
60429     }
60430   }
60431
60432   jresult = (int)result;
60433   return jresult;
60434 }
60435
60436
60437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60438   int jresult ;
60439   int result;
60440
60441   {
60442     try {
60443       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60444     } catch (std::out_of_range& e) {
60445       {
60446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60447       };
60448     } catch (std::exception& e) {
60449       {
60450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60451       };
60452     } catch (Dali::DaliException e) {
60453       {
60454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60455       };
60456     } catch (...) {
60457       {
60458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60459       };
60460     }
60461   }
60462
60463   jresult = (int)result;
60464   return jresult;
60465 }
60466
60467
60468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60469   int jresult ;
60470   int result;
60471
60472   {
60473     try {
60474       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60475     } catch (std::out_of_range& e) {
60476       {
60477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60478       };
60479     } catch (std::exception& e) {
60480       {
60481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60482       };
60483     } catch (Dali::DaliException e) {
60484       {
60485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60486       };
60487     } catch (...) {
60488       {
60489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60490       };
60491     }
60492   }
60493
60494   jresult = (int)result;
60495   return jresult;
60496 }
60497
60498
60499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60500   int jresult ;
60501   int result;
60502
60503   {
60504     try {
60505       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60506     } catch (std::out_of_range& e) {
60507       {
60508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60509       };
60510     } catch (std::exception& e) {
60511       {
60512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60513       };
60514     } catch (Dali::DaliException e) {
60515       {
60516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60517       };
60518     } catch (...) {
60519       {
60520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60521       };
60522     }
60523   }
60524
60525   jresult = (int)result;
60526   return jresult;
60527 }
60528
60529
60530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60531   int jresult ;
60532   int result;
60533
60534   {
60535     try {
60536       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60537     } catch (std::out_of_range& e) {
60538       {
60539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60540       };
60541     } catch (std::exception& e) {
60542       {
60543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60544       };
60545     } catch (Dali::DaliException e) {
60546       {
60547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60548       };
60549     } catch (...) {
60550       {
60551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60552       };
60553     }
60554   }
60555
60556   jresult = (int)result;
60557   return jresult;
60558 }
60559
60560
60561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60562   int jresult ;
60563   int result;
60564
60565   {
60566     try {
60567       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60568     } catch (std::out_of_range& e) {
60569       {
60570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60571       };
60572     } catch (std::exception& e) {
60573       {
60574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60575       };
60576     } catch (Dali::DaliException e) {
60577       {
60578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60579       };
60580     } catch (...) {
60581       {
60582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60583       };
60584     }
60585   }
60586
60587   jresult = (int)result;
60588   return jresult;
60589 }
60590
60591
60592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60593   int jresult ;
60594   int result;
60595
60596   {
60597     try {
60598       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60599     } catch (std::out_of_range& e) {
60600       {
60601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60602       };
60603     } catch (std::exception& e) {
60604       {
60605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60606       };
60607     } catch (Dali::DaliException e) {
60608       {
60609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60610       };
60611     } catch (...) {
60612       {
60613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60614       };
60615     }
60616   }
60617
60618   jresult = (int)result;
60619   return jresult;
60620 }
60621
60622
60623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60624   int jresult ;
60625   int result;
60626
60627   {
60628     try {
60629       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60630     } catch (std::out_of_range& e) {
60631       {
60632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60633       };
60634     } catch (std::exception& e) {
60635       {
60636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60637       };
60638     } catch (Dali::DaliException e) {
60639       {
60640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60641       };
60642     } catch (...) {
60643       {
60644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60645       };
60646     }
60647   }
60648
60649   jresult = (int)result;
60650   return jresult;
60651 }
60652
60653
60654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60655   int jresult ;
60656   int result;
60657
60658   {
60659     try {
60660       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60661     } catch (std::out_of_range& e) {
60662       {
60663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60664       };
60665     } catch (std::exception& e) {
60666       {
60667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60668       };
60669     } catch (Dali::DaliException e) {
60670       {
60671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60672       };
60673     } catch (...) {
60674       {
60675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60676       };
60677     }
60678   }
60679
60680   jresult = (int)result;
60681   return jresult;
60682 }
60683
60684
60685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60686   int jresult ;
60687   int result;
60688
60689   {
60690     try {
60691       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60692     } catch (std::out_of_range& e) {
60693       {
60694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60695       };
60696     } catch (std::exception& e) {
60697       {
60698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60699       };
60700     } catch (Dali::DaliException e) {
60701       {
60702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60703       };
60704     } catch (...) {
60705       {
60706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60707       };
60708     }
60709   }
60710
60711   jresult = (int)result;
60712   return jresult;
60713 }
60714
60715
60716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60717   int jresult ;
60718   int result;
60719
60720   {
60721     try {
60722       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60723     } catch (std::out_of_range& e) {
60724       {
60725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60726       };
60727     } catch (std::exception& e) {
60728       {
60729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60730       };
60731     } catch (Dali::DaliException e) {
60732       {
60733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60734       };
60735     } catch (...) {
60736       {
60737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60738       };
60739     }
60740   }
60741
60742   jresult = (int)result;
60743   return jresult;
60744 }
60745
60746
60747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60748   int jresult ;
60749   int result;
60750
60751   {
60752     try {
60753       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60754     } catch (std::out_of_range& e) {
60755       {
60756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60757       };
60758     } catch (std::exception& e) {
60759       {
60760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60761       };
60762     } catch (Dali::DaliException e) {
60763       {
60764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60765       };
60766     } catch (...) {
60767       {
60768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60769       };
60770     }
60771   }
60772
60773   jresult = (int)result;
60774   return jresult;
60775 }
60776
60777
60778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60779   int jresult ;
60780   int result;
60781
60782   {
60783     try {
60784       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60785     } catch (std::out_of_range& e) {
60786       {
60787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60788       };
60789     } catch (std::exception& e) {
60790       {
60791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60792       };
60793     } catch (Dali::DaliException e) {
60794       {
60795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60796       };
60797     } catch (...) {
60798       {
60799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60800       };
60801     }
60802   }
60803
60804   jresult = (int)result;
60805   return jresult;
60806 }
60807
60808
60809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60810   int jresult ;
60811   int result;
60812
60813   {
60814     try {
60815       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60816     } catch (std::out_of_range& e) {
60817       {
60818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60819       };
60820     } catch (std::exception& e) {
60821       {
60822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60823       };
60824     } catch (Dali::DaliException e) {
60825       {
60826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60827       };
60828     } catch (...) {
60829       {
60830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60831       };
60832     }
60833   }
60834
60835   jresult = (int)result;
60836   return jresult;
60837 }
60838
60839
60840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60841   int jresult ;
60842   int result;
60843
60844   {
60845     try {
60846       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60847     } catch (std::out_of_range& e) {
60848       {
60849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60850       };
60851     } catch (std::exception& e) {
60852       {
60853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60854       };
60855     } catch (Dali::DaliException e) {
60856       {
60857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60858       };
60859     } catch (...) {
60860       {
60861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60862       };
60863     }
60864   }
60865
60866   jresult = (int)result;
60867   return jresult;
60868 }
60869
60870
60871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60872   int jresult ;
60873   int result;
60874
60875   {
60876     try {
60877       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60878     } catch (std::out_of_range& e) {
60879       {
60880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60881       };
60882     } catch (std::exception& e) {
60883       {
60884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60885       };
60886     } catch (Dali::DaliException e) {
60887       {
60888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60889       };
60890     } catch (...) {
60891       {
60892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60893       };
60894     }
60895   }
60896
60897   jresult = (int)result;
60898   return jresult;
60899 }
60900
60901
60902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
60903   int jresult ;
60904   int result;
60905
60906   {
60907     try {
60908       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
60909     } catch (std::out_of_range& e) {
60910       {
60911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60912       };
60913     } catch (std::exception& e) {
60914       {
60915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60916       };
60917     } catch (Dali::DaliException e) {
60918       {
60919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60920       };
60921     } catch (...) {
60922       {
60923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60924       };
60925     }
60926   }
60927
60928   jresult = (int)result;
60929   return jresult;
60930 }
60931
60932
60933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
60934   int jresult ;
60935   int result;
60936
60937   {
60938     try {
60939       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
60940     } catch (std::out_of_range& e) {
60941       {
60942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60943       };
60944     } catch (std::exception& e) {
60945       {
60946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60947       };
60948     } catch (Dali::DaliException e) {
60949       {
60950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60951       };
60952     } catch (...) {
60953       {
60954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60955       };
60956     }
60957   }
60958
60959   jresult = (int)result;
60960   return jresult;
60961 }
60962
60963
60964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
60965   int jresult ;
60966   int result;
60967
60968   {
60969     try {
60970       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
60971     } catch (std::out_of_range& e) {
60972       {
60973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60974       };
60975     } catch (std::exception& e) {
60976       {
60977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60978       };
60979     } catch (Dali::DaliException e) {
60980       {
60981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60982       };
60983     } catch (...) {
60984       {
60985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60986       };
60987     }
60988   }
60989
60990   jresult = (int)result;
60991   return jresult;
60992 }
60993
60994
60995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
60996   int jresult ;
60997   int result;
60998
60999   {
61000     try {
61001       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61002     } catch (std::out_of_range& e) {
61003       {
61004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61005       };
61006     } catch (std::exception& e) {
61007       {
61008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61009       };
61010     } catch (Dali::DaliException e) {
61011       {
61012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61013       };
61014     } catch (...) {
61015       {
61016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61017       };
61018     }
61019   }
61020
61021   jresult = (int)result;
61022   return jresult;
61023 }
61024
61025
61026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61027   int jresult ;
61028   int result;
61029
61030   {
61031     try {
61032       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61033     } catch (std::out_of_range& e) {
61034       {
61035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61036       };
61037     } catch (std::exception& e) {
61038       {
61039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61040       };
61041     } catch (Dali::DaliException e) {
61042       {
61043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61044       };
61045     } catch (...) {
61046       {
61047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61048       };
61049     }
61050   }
61051
61052   jresult = (int)result;
61053   return jresult;
61054 }
61055
61056
61057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61058   int jresult ;
61059   int result;
61060
61061   {
61062     try {
61063       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61064     } catch (std::out_of_range& e) {
61065       {
61066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61067       };
61068     } catch (std::exception& e) {
61069       {
61070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61071       };
61072     } catch (Dali::DaliException e) {
61073       {
61074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61075       };
61076     } catch (...) {
61077       {
61078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61079       };
61080     }
61081   }
61082
61083   jresult = (int)result;
61084   return jresult;
61085 }
61086
61087
61088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61089   int jresult ;
61090   int result;
61091
61092   {
61093     try {
61094       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61095     } catch (std::out_of_range& e) {
61096       {
61097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61098       };
61099     } catch (std::exception& e) {
61100       {
61101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61102       };
61103     } catch (Dali::DaliException e) {
61104       {
61105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61106       };
61107     } catch (...) {
61108       {
61109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61110       };
61111     }
61112   }
61113
61114   jresult = (int)result;
61115   return jresult;
61116 }
61117
61118
61119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61120   void * jresult ;
61121   Dali::Toolkit::Builder *result = 0 ;
61122
61123   {
61124     try {
61125       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61126     } catch (std::out_of_range& e) {
61127       {
61128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61129       };
61130     } catch (std::exception& e) {
61131       {
61132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61133       };
61134     } catch (Dali::DaliException e) {
61135       {
61136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61137       };
61138     } catch (...) {
61139       {
61140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61141       };
61142     }
61143   }
61144
61145   jresult = (void *)result;
61146   return jresult;
61147 }
61148
61149
61150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61151   void * jresult ;
61152   Dali::Toolkit::Builder result;
61153
61154   {
61155     try {
61156       result = Dali::Toolkit::Builder::New();
61157     } catch (std::out_of_range& e) {
61158       {
61159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61160       };
61161     } catch (std::exception& e) {
61162       {
61163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61164       };
61165     } catch (Dali::DaliException e) {
61166       {
61167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61168       };
61169     } catch (...) {
61170       {
61171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61172       };
61173     }
61174   }
61175
61176   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61177   return jresult;
61178 }
61179
61180
61181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61182   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61183
61184   arg1 = (Dali::Toolkit::Builder *)jarg1;
61185   {
61186     try {
61187       delete arg1;
61188     } catch (std::out_of_range& e) {
61189       {
61190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61191       };
61192     } catch (std::exception& e) {
61193       {
61194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61195       };
61196     } catch (Dali::DaliException e) {
61197       {
61198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61199       };
61200     } catch (...) {
61201       {
61202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61203       };
61204     }
61205   }
61206
61207 }
61208
61209
61210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61211   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61212   std::string *arg2 = 0 ;
61213   Dali::Toolkit::Builder::UIFormat arg3 ;
61214
61215   arg1 = (Dali::Toolkit::Builder *)jarg1;
61216   if (!jarg2) {
61217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61218     return ;
61219   }
61220   std::string arg2_str(jarg2);
61221   arg2 = &arg2_str;
61222   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61223   {
61224     try {
61225       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61226     } catch (std::out_of_range& e) {
61227       {
61228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61229       };
61230     } catch (std::exception& e) {
61231       {
61232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61233       };
61234     } catch (Dali::DaliException e) {
61235       {
61236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61237       };
61238     } catch (...) {
61239       {
61240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61241       };
61242     }
61243   }
61244
61245
61246   //argout typemap for const std::string&
61247
61248 }
61249
61250
61251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61252   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61253   std::string *arg2 = 0 ;
61254
61255   arg1 = (Dali::Toolkit::Builder *)jarg1;
61256   if (!jarg2) {
61257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61258     return ;
61259   }
61260   std::string arg2_str(jarg2);
61261   arg2 = &arg2_str;
61262   {
61263     try {
61264       (arg1)->LoadFromString((std::string const &)*arg2);
61265     } catch (std::out_of_range& e) {
61266       {
61267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61268       };
61269     } catch (std::exception& e) {
61270       {
61271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61272       };
61273     } catch (Dali::DaliException e) {
61274       {
61275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61276       };
61277     } catch (...) {
61278       {
61279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61280       };
61281     }
61282   }
61283
61284
61285   //argout typemap for const std::string&
61286
61287 }
61288
61289
61290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61291   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61292   Dali::Property::Map *arg2 = 0 ;
61293
61294   arg1 = (Dali::Toolkit::Builder *)jarg1;
61295   arg2 = (Dali::Property::Map *)jarg2;
61296   if (!arg2) {
61297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61298     return ;
61299   }
61300   {
61301     try {
61302       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61303     } catch (std::out_of_range& e) {
61304       {
61305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61306       };
61307     } catch (std::exception& e) {
61308       {
61309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61310       };
61311     } catch (Dali::DaliException e) {
61312       {
61313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61314       };
61315     } catch (...) {
61316       {
61317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61318       };
61319     }
61320   }
61321
61322 }
61323
61324
61325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61326   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61327   std::string *arg2 = 0 ;
61328   Dali::Property::Value *arg3 = 0 ;
61329
61330   arg1 = (Dali::Toolkit::Builder *)jarg1;
61331   if (!jarg2) {
61332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61333     return ;
61334   }
61335   std::string arg2_str(jarg2);
61336   arg2 = &arg2_str;
61337   arg3 = (Dali::Property::Value *)jarg3;
61338   if (!arg3) {
61339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61340     return ;
61341   }
61342   {
61343     try {
61344       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61345     } catch (std::out_of_range& e) {
61346       {
61347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61348       };
61349     } catch (std::exception& e) {
61350       {
61351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61352       };
61353     } catch (Dali::DaliException e) {
61354       {
61355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61356       };
61357     } catch (...) {
61358       {
61359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61360       };
61361     }
61362   }
61363
61364
61365   //argout typemap for const std::string&
61366
61367 }
61368
61369
61370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61371   void * jresult ;
61372   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61373   Dali::Property::Map *result = 0 ;
61374
61375   arg1 = (Dali::Toolkit::Builder *)jarg1;
61376   {
61377     try {
61378       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61379     } catch (std::out_of_range& e) {
61380       {
61381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61382       };
61383     } catch (std::exception& e) {
61384       {
61385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61386       };
61387     } catch (Dali::DaliException e) {
61388       {
61389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61390       };
61391     } catch (...) {
61392       {
61393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61394       };
61395     }
61396   }
61397
61398   jresult = (void *)result;
61399   return jresult;
61400 }
61401
61402
61403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61404   void * jresult ;
61405   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61406   std::string *arg2 = 0 ;
61407   Dali::Property::Value *result = 0 ;
61408
61409   arg1 = (Dali::Toolkit::Builder *)jarg1;
61410   if (!jarg2) {
61411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61412     return 0;
61413   }
61414   std::string arg2_str(jarg2);
61415   arg2 = &arg2_str;
61416   {
61417     try {
61418       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61419     } catch (std::out_of_range& e) {
61420       {
61421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61422       };
61423     } catch (std::exception& e) {
61424       {
61425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61426       };
61427     } catch (Dali::DaliException e) {
61428       {
61429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61430       };
61431     } catch (...) {
61432       {
61433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61434       };
61435     }
61436   }
61437
61438   jresult = (void *)result;
61439
61440   //argout typemap for const std::string&
61441
61442   return jresult;
61443 }
61444
61445
61446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61447   void * jresult ;
61448   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61449   std::string *arg2 = 0 ;
61450   Dali::Animation result;
61451
61452   arg1 = (Dali::Toolkit::Builder *)jarg1;
61453   if (!jarg2) {
61454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61455     return 0;
61456   }
61457   std::string arg2_str(jarg2);
61458   arg2 = &arg2_str;
61459   {
61460     try {
61461       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61462     } catch (std::out_of_range& e) {
61463       {
61464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61465       };
61466     } catch (std::exception& e) {
61467       {
61468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61469       };
61470     } catch (Dali::DaliException e) {
61471       {
61472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61473       };
61474     } catch (...) {
61475       {
61476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61477       };
61478     }
61479   }
61480
61481   jresult = new Dali::Animation((const Dali::Animation &)result);
61482
61483   //argout typemap for const std::string&
61484
61485   return jresult;
61486 }
61487
61488
61489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61490   void * jresult ;
61491   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61492   std::string *arg2 = 0 ;
61493   Dali::Property::Map *arg3 = 0 ;
61494   Dali::Animation result;
61495
61496   arg1 = (Dali::Toolkit::Builder *)jarg1;
61497   if (!jarg2) {
61498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61499     return 0;
61500   }
61501   std::string arg2_str(jarg2);
61502   arg2 = &arg2_str;
61503   arg3 = (Dali::Property::Map *)jarg3;
61504   if (!arg3) {
61505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61506     return 0;
61507   }
61508   {
61509     try {
61510       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61511     } catch (std::out_of_range& e) {
61512       {
61513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61514       };
61515     } catch (std::exception& e) {
61516       {
61517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61518       };
61519     } catch (Dali::DaliException e) {
61520       {
61521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61522       };
61523     } catch (...) {
61524       {
61525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61526       };
61527     }
61528   }
61529
61530   jresult = new Dali::Animation((const Dali::Animation &)result);
61531
61532   //argout typemap for const std::string&
61533
61534   return jresult;
61535 }
61536
61537
61538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61539   void * jresult ;
61540   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61541   std::string *arg2 = 0 ;
61542   Dali::Actor arg3 ;
61543   Dali::Actor *argp3 ;
61544   Dali::Animation result;
61545
61546   arg1 = (Dali::Toolkit::Builder *)jarg1;
61547   if (!jarg2) {
61548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61549     return 0;
61550   }
61551   std::string arg2_str(jarg2);
61552   arg2 = &arg2_str;
61553   argp3 = (Dali::Actor *)jarg3;
61554   if (!argp3) {
61555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61556     return 0;
61557   }
61558   arg3 = *argp3;
61559   {
61560     try {
61561       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61562     } catch (std::out_of_range& e) {
61563       {
61564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61565       };
61566     } catch (std::exception& e) {
61567       {
61568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61569       };
61570     } catch (Dali::DaliException e) {
61571       {
61572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61573       };
61574     } catch (...) {
61575       {
61576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61577       };
61578     }
61579   }
61580
61581   jresult = new Dali::Animation((const Dali::Animation &)result);
61582
61583   //argout typemap for const std::string&
61584
61585   return jresult;
61586 }
61587
61588
61589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61590   void * jresult ;
61591   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61592   std::string *arg2 = 0 ;
61593   Dali::Property::Map *arg3 = 0 ;
61594   Dali::Actor arg4 ;
61595   Dali::Actor *argp4 ;
61596   Dali::Animation result;
61597
61598   arg1 = (Dali::Toolkit::Builder *)jarg1;
61599   if (!jarg2) {
61600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61601     return 0;
61602   }
61603   std::string arg2_str(jarg2);
61604   arg2 = &arg2_str;
61605   arg3 = (Dali::Property::Map *)jarg3;
61606   if (!arg3) {
61607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61608     return 0;
61609   }
61610   argp4 = (Dali::Actor *)jarg4;
61611   if (!argp4) {
61612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61613     return 0;
61614   }
61615   arg4 = *argp4;
61616   {
61617     try {
61618       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61619     } catch (std::out_of_range& e) {
61620       {
61621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61622       };
61623     } catch (std::exception& e) {
61624       {
61625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61626       };
61627     } catch (Dali::DaliException e) {
61628       {
61629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61630       };
61631     } catch (...) {
61632       {
61633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61634       };
61635     }
61636   }
61637
61638   jresult = new Dali::Animation((const Dali::Animation &)result);
61639
61640   //argout typemap for const std::string&
61641
61642   return jresult;
61643 }
61644
61645
61646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61647   void * jresult ;
61648   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61649   std::string *arg2 = 0 ;
61650   Dali::BaseHandle result;
61651
61652   arg1 = (Dali::Toolkit::Builder *)jarg1;
61653   if (!jarg2) {
61654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61655     return 0;
61656   }
61657   std::string arg2_str(jarg2);
61658   arg2 = &arg2_str;
61659   {
61660     try {
61661       result = (arg1)->Create((std::string const &)*arg2);
61662     } catch (std::out_of_range& e) {
61663       {
61664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61665       };
61666     } catch (std::exception& e) {
61667       {
61668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61669       };
61670     } catch (Dali::DaliException e) {
61671       {
61672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61673       };
61674     } catch (...) {
61675       {
61676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61677       };
61678     }
61679   }
61680
61681   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61682
61683   //argout typemap for const std::string&
61684
61685   return jresult;
61686 }
61687
61688
61689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61690   void * jresult ;
61691   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61692   std::string *arg2 = 0 ;
61693   Dali::Property::Map *arg3 = 0 ;
61694   Dali::BaseHandle result;
61695
61696   arg1 = (Dali::Toolkit::Builder *)jarg1;
61697   if (!jarg2) {
61698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61699     return 0;
61700   }
61701   std::string arg2_str(jarg2);
61702   arg2 = &arg2_str;
61703   arg3 = (Dali::Property::Map *)jarg3;
61704   if (!arg3) {
61705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61706     return 0;
61707   }
61708   {
61709     try {
61710       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61711     } catch (std::out_of_range& e) {
61712       {
61713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61714       };
61715     } catch (std::exception& e) {
61716       {
61717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61718       };
61719     } catch (Dali::DaliException e) {
61720       {
61721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61722       };
61723     } catch (...) {
61724       {
61725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61726       };
61727     }
61728   }
61729
61730   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61731
61732   //argout typemap for const std::string&
61733
61734   return jresult;
61735 }
61736
61737
61738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61739   void * jresult ;
61740   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61741   std::string *arg2 = 0 ;
61742   Dali::BaseHandle result;
61743
61744   arg1 = (Dali::Toolkit::Builder *)jarg1;
61745   if (!jarg2) {
61746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61747     return 0;
61748   }
61749   std::string arg2_str(jarg2);
61750   arg2 = &arg2_str;
61751   {
61752     try {
61753       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61754     } catch (std::out_of_range& e) {
61755       {
61756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61757       };
61758     } catch (std::exception& e) {
61759       {
61760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61761       };
61762     } catch (Dali::DaliException e) {
61763       {
61764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61765       };
61766     } catch (...) {
61767       {
61768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61769       };
61770     }
61771   }
61772
61773   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61774
61775   //argout typemap for const std::string&
61776
61777   return jresult;
61778 }
61779
61780
61781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61782   unsigned int jresult ;
61783   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61784   std::string *arg2 = 0 ;
61785   Dali::Handle *arg3 = 0 ;
61786   bool result;
61787
61788   arg1 = (Dali::Toolkit::Builder *)jarg1;
61789   if (!jarg2) {
61790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61791     return 0;
61792   }
61793   std::string arg2_str(jarg2);
61794   arg2 = &arg2_str;
61795   arg3 = (Dali::Handle *)jarg3;
61796   if (!arg3) {
61797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61798     return 0;
61799   }
61800   {
61801     try {
61802       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61803     } catch (std::out_of_range& e) {
61804       {
61805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61806       };
61807     } catch (std::exception& e) {
61808       {
61809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61810       };
61811     } catch (Dali::DaliException e) {
61812       {
61813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61814       };
61815     } catch (...) {
61816       {
61817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61818       };
61819     }
61820   }
61821
61822   jresult = result;
61823
61824   //argout typemap for const std::string&
61825
61826   return jresult;
61827 }
61828
61829
61830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61831   unsigned int jresult ;
61832   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61833   Dali::Handle *arg2 = 0 ;
61834   std::string *arg3 = 0 ;
61835   bool result;
61836
61837   arg1 = (Dali::Toolkit::Builder *)jarg1;
61838   arg2 = (Dali::Handle *)jarg2;
61839   if (!arg2) {
61840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61841     return 0;
61842   }
61843   if (!jarg3) {
61844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61845     return 0;
61846   }
61847   std::string arg3_str(jarg3);
61848   arg3 = &arg3_str;
61849   {
61850     try {
61851       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61852     } catch (std::out_of_range& e) {
61853       {
61854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61855       };
61856     } catch (std::exception& e) {
61857       {
61858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61859       };
61860     } catch (Dali::DaliException e) {
61861       {
61862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61863       };
61864     } catch (...) {
61865       {
61866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61867       };
61868     }
61869   }
61870
61871   jresult = result;
61872
61873   //argout typemap for const std::string&
61874
61875   return jresult;
61876 }
61877
61878
61879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61880   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61881   Dali::Actor arg2 ;
61882   Dali::Actor *argp2 ;
61883
61884   arg1 = (Dali::Toolkit::Builder *)jarg1;
61885   argp2 = (Dali::Actor *)jarg2;
61886   if (!argp2) {
61887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61888     return ;
61889   }
61890   arg2 = *argp2;
61891   {
61892     try {
61893       (arg1)->AddActors(arg2);
61894     } catch (std::out_of_range& e) {
61895       {
61896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61897       };
61898     } catch (std::exception& e) {
61899       {
61900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61901       };
61902     } catch (Dali::DaliException e) {
61903       {
61904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61905       };
61906     } catch (...) {
61907       {
61908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61909       };
61910     }
61911   }
61912
61913 }
61914
61915
61916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61917   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61918   std::string *arg2 = 0 ;
61919   Dali::Actor arg3 ;
61920   Dali::Actor *argp3 ;
61921
61922   arg1 = (Dali::Toolkit::Builder *)jarg1;
61923   if (!jarg2) {
61924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61925     return ;
61926   }
61927   std::string arg2_str(jarg2);
61928   arg2 = &arg2_str;
61929   argp3 = (Dali::Actor *)jarg3;
61930   if (!argp3) {
61931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61932     return ;
61933   }
61934   arg3 = *argp3;
61935   {
61936     try {
61937       (arg1)->AddActors((std::string const &)*arg2,arg3);
61938     } catch (std::out_of_range& e) {
61939       {
61940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61941       };
61942     } catch (std::exception& e) {
61943       {
61944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61945       };
61946     } catch (Dali::DaliException e) {
61947       {
61948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61949       };
61950     } catch (...) {
61951       {
61952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61953       };
61954     }
61955   }
61956
61957
61958   //argout typemap for const std::string&
61959
61960 }
61961
61962
61963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
61964   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61965   std::string *arg2 = 0 ;
61966
61967   arg1 = (Dali::Toolkit::Builder *)jarg1;
61968   if (!jarg2) {
61969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61970     return ;
61971   }
61972   std::string arg2_str(jarg2);
61973   arg2 = &arg2_str;
61974   {
61975     try {
61976       (arg1)->CreateRenderTask((std::string const &)*arg2);
61977     } catch (std::out_of_range& e) {
61978       {
61979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61980       };
61981     } catch (std::exception& e) {
61982       {
61983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61984       };
61985     } catch (Dali::DaliException e) {
61986       {
61987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61988       };
61989     } catch (...) {
61990       {
61991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61992       };
61993     }
61994   }
61995
61996
61997   //argout typemap for const std::string&
61998
61999 }
62000
62001
62002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62003   void * jresult ;
62004   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62005   std::string *arg2 = 0 ;
62006   Dali::FrameBufferImage result;
62007
62008   arg1 = (Dali::Toolkit::Builder *)jarg1;
62009   if (!jarg2) {
62010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62011     return 0;
62012   }
62013   std::string arg2_str(jarg2);
62014   arg2 = &arg2_str;
62015   {
62016     try {
62017       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62018     } catch (std::out_of_range& e) {
62019       {
62020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62021       };
62022     } catch (std::exception& e) {
62023       {
62024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62025       };
62026     } catch (Dali::DaliException e) {
62027       {
62028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62029       };
62030     } catch (...) {
62031       {
62032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62033       };
62034     }
62035   }
62036
62037   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62038
62039   //argout typemap for const std::string&
62040
62041   return jresult;
62042 }
62043
62044
62045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62046   void * jresult ;
62047   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62048   std::string *arg2 = 0 ;
62049   Dali::Path result;
62050
62051   arg1 = (Dali::Toolkit::Builder *)jarg1;
62052   if (!jarg2) {
62053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62054     return 0;
62055   }
62056   std::string arg2_str(jarg2);
62057   arg2 = &arg2_str;
62058   {
62059     try {
62060       result = (arg1)->GetPath((std::string const &)*arg2);
62061     } catch (std::out_of_range& e) {
62062       {
62063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62064       };
62065     } catch (std::exception& e) {
62066       {
62067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62068       };
62069     } catch (Dali::DaliException e) {
62070       {
62071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62072       };
62073     } catch (...) {
62074       {
62075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62076       };
62077     }
62078   }
62079
62080   jresult = new Dali::Path((const Dali::Path &)result);
62081
62082   //argout typemap for const std::string&
62083
62084   return jresult;
62085 }
62086
62087
62088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62089   void * jresult ;
62090   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62091   std::string *arg2 = 0 ;
62092   Dali::PathConstrainer result;
62093
62094   arg1 = (Dali::Toolkit::Builder *)jarg1;
62095   if (!jarg2) {
62096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62097     return 0;
62098   }
62099   std::string arg2_str(jarg2);
62100   arg2 = &arg2_str;
62101   {
62102     try {
62103       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62104     } catch (std::out_of_range& e) {
62105       {
62106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62107       };
62108     } catch (std::exception& e) {
62109       {
62110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62111       };
62112     } catch (Dali::DaliException e) {
62113       {
62114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62115       };
62116     } catch (...) {
62117       {
62118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62119       };
62120     }
62121   }
62122
62123   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62124
62125   //argout typemap for const std::string&
62126
62127   return jresult;
62128 }
62129
62130
62131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62132   void * jresult ;
62133   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62134   std::string *arg2 = 0 ;
62135   Dali::LinearConstrainer result;
62136
62137   arg1 = (Dali::Toolkit::Builder *)jarg1;
62138   if (!jarg2) {
62139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62140     return 0;
62141   }
62142   std::string arg2_str(jarg2);
62143   arg2 = &arg2_str;
62144   {
62145     try {
62146       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62147     } catch (std::out_of_range& e) {
62148       {
62149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62150       };
62151     } catch (std::exception& e) {
62152       {
62153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62154       };
62155     } catch (Dali::DaliException e) {
62156       {
62157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62158       };
62159     } catch (...) {
62160       {
62161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62162       };
62163     }
62164   }
62165
62166   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62167
62168   //argout typemap for const std::string&
62169
62170   return jresult;
62171 }
62172
62173
62174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62175   void * jresult ;
62176   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62177   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62178
62179   arg1 = (Dali::Toolkit::Builder *)jarg1;
62180   {
62181     try {
62182       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62183     } catch (std::out_of_range& e) {
62184       {
62185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62186       };
62187     } catch (std::exception& e) {
62188       {
62189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62190       };
62191     } catch (Dali::DaliException e) {
62192       {
62193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62194       };
62195     } catch (...) {
62196       {
62197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62198       };
62199     }
62200   }
62201
62202   jresult = (void *)result;
62203   return jresult;
62204 }
62205
62206
62207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62208   void * jresult ;
62209   Dali::Toolkit::TransitionData *result = 0 ;
62210
62211   {
62212     try {
62213       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62214     } catch (std::out_of_range& e) {
62215       {
62216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62217       };
62218     } catch (std::exception& e) {
62219       {
62220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62221       };
62222     } catch (Dali::DaliException e) {
62223       {
62224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62225       };
62226     } catch (...) {
62227       {
62228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62229       };
62230     }
62231   }
62232
62233   jresult = (void *)result;
62234   return jresult;
62235 }
62236
62237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62238   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62239
62240   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62241   {
62242     try {
62243       delete arg1;
62244     } catch (std::out_of_range& e) {
62245       {
62246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62247       };
62248     } catch (std::exception& e) {
62249       {
62250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62251       };
62252     } catch (Dali::DaliException e) {
62253       {
62254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62255       };
62256     } catch (...) {
62257       {
62258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62259       };
62260     }
62261   }
62262
62263 }
62264
62265
62266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62267   void * jresult ;
62268   Dali::Property::Map *arg1 = 0 ;
62269   Dali::Toolkit::TransitionData result;
62270
62271   arg1 = (Dali::Property::Map *)jarg1;
62272   if (!arg1) {
62273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62274     return 0;
62275   }
62276   {
62277     try {
62278       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62279     } catch (std::out_of_range& e) {
62280       {
62281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62282       };
62283     } catch (std::exception& e) {
62284       {
62285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62286       };
62287     } catch (Dali::DaliException e) {
62288       {
62289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62290       };
62291     } catch (...) {
62292       {
62293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62294       };
62295     }
62296   }
62297
62298   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62299   return jresult;
62300 }
62301
62302
62303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62304   void * jresult ;
62305   Dali::Property::Array *arg1 = 0 ;
62306   Dali::Toolkit::TransitionData result;
62307
62308   arg1 = (Dali::Property::Array *)jarg1;
62309   if (!arg1) {
62310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62311     return 0;
62312   }
62313   {
62314     try {
62315       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62316     } catch (std::out_of_range& e) {
62317       {
62318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62319       };
62320     } catch (std::exception& e) {
62321       {
62322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62323       };
62324     } catch (Dali::DaliException e) {
62325       {
62326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62327       };
62328     } catch (...) {
62329       {
62330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62331       };
62332     }
62333   }
62334
62335   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62336   return jresult;
62337 }
62338
62339
62340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62341   void * jresult ;
62342   Dali::BaseHandle arg1 ;
62343   Dali::BaseHandle *argp1 ;
62344   Dali::Toolkit::TransitionData result;
62345
62346   argp1 = (Dali::BaseHandle *)jarg1;
62347   if (!argp1) {
62348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62349     return 0;
62350   }
62351   arg1 = *argp1;
62352   {
62353     try {
62354       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62355     } catch (std::out_of_range& e) {
62356       {
62357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62358       };
62359     } catch (std::exception& e) {
62360       {
62361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62362       };
62363     } catch (Dali::DaliException e) {
62364       {
62365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62366       };
62367     } catch (...) {
62368       {
62369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62370       };
62371     }
62372   }
62373
62374   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62375   return jresult;
62376 }
62377
62378
62379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62380   void * jresult ;
62381   Dali::Toolkit::TransitionData *arg1 = 0 ;
62382   Dali::Toolkit::TransitionData *result = 0 ;
62383
62384   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62385   if (!arg1) {
62386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62387     return 0;
62388   }
62389   {
62390     try {
62391       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62392     } catch (std::out_of_range& e) {
62393       {
62394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62395       };
62396     } catch (std::exception& e) {
62397       {
62398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62399       };
62400     } catch (Dali::DaliException e) {
62401       {
62402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62403       };
62404     } catch (...) {
62405       {
62406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62407       };
62408     }
62409   }
62410
62411   jresult = (void *)result;
62412   return jresult;
62413 }
62414
62415
62416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62417   void * jresult ;
62418   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62419   Dali::Toolkit::TransitionData *arg2 = 0 ;
62420   Dali::Toolkit::TransitionData *result = 0 ;
62421
62422   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62423   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62424   if (!arg2) {
62425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62426     return 0;
62427   }
62428   {
62429     try {
62430       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62431     } catch (std::out_of_range& e) {
62432       {
62433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62434       };
62435     } catch (std::exception& e) {
62436       {
62437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62438       };
62439     } catch (Dali::DaliException e) {
62440       {
62441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62442       };
62443     } catch (...) {
62444       {
62445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62446       };
62447     }
62448   }
62449
62450   jresult = (void *)result;
62451   return jresult;
62452 }
62453
62454
62455 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62456   unsigned long jresult ;
62457   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62458   size_t result;
62459
62460   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62461   {
62462     try {
62463       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62464     } catch (std::out_of_range& e) {
62465       {
62466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62467       };
62468     } catch (std::exception& e) {
62469       {
62470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62471       };
62472     } catch (Dali::DaliException e) {
62473       {
62474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62475       };
62476     } catch (...) {
62477       {
62478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62479       };
62480     }
62481   }
62482
62483   jresult = (unsigned long)result;
62484   return jresult;
62485 }
62486
62487
62488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62489   void * jresult ;
62490   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62491   size_t arg2 ;
62492   Dali::Property::Map result;
62493
62494   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62495   arg2 = (size_t)jarg2;
62496   {
62497     try {
62498       result = (arg1)->GetAnimatorAt(arg2);
62499     } catch (std::out_of_range& e) {
62500       {
62501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62502       };
62503     } catch (std::exception& e) {
62504       {
62505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62506       };
62507     } catch (Dali::DaliException e) {
62508       {
62509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62510       };
62511     } catch (...) {
62512       {
62513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62514       };
62515     }
62516   }
62517
62518   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62519   return jresult;
62520 }
62521
62522
62523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62524   int jresult ;
62525   int result;
62526
62527   {
62528     try {
62529       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62530     } catch (std::out_of_range& e) {
62531       {
62532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62533       };
62534     } catch (std::exception& e) {
62535       {
62536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62537       };
62538     } catch (Dali::DaliException e) {
62539       {
62540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62541       };
62542     } catch (...) {
62543       {
62544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62545       };
62546     }
62547   }
62548
62549   jresult = (int)result;
62550   return jresult;
62551 }
62552
62553
62554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62555   int jresult ;
62556   int result;
62557
62558   {
62559     try {
62560       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62561     } catch (std::out_of_range& e) {
62562       {
62563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62564       };
62565     } catch (std::exception& e) {
62566       {
62567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62568       };
62569     } catch (Dali::DaliException e) {
62570       {
62571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62572       };
62573     } catch (...) {
62574       {
62575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62576       };
62577     }
62578   }
62579
62580   jresult = (int)result;
62581   return jresult;
62582 }
62583
62584
62585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62586   int jresult ;
62587   int result;
62588
62589   {
62590     try {
62591       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62592     } catch (std::out_of_range& e) {
62593       {
62594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62595       };
62596     } catch (std::exception& e) {
62597       {
62598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62599       };
62600     } catch (Dali::DaliException e) {
62601       {
62602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62603       };
62604     } catch (...) {
62605       {
62606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62607       };
62608     }
62609   }
62610
62611   jresult = (int)result;
62612   return jresult;
62613 }
62614
62615
62616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62617   int jresult ;
62618   int result;
62619
62620   {
62621     try {
62622       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62623     } catch (std::out_of_range& e) {
62624       {
62625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62626       };
62627     } catch (std::exception& e) {
62628       {
62629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62630       };
62631     } catch (Dali::DaliException e) {
62632       {
62633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62634       };
62635     } catch (...) {
62636       {
62637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62638       };
62639     }
62640   }
62641
62642   jresult = (int)result;
62643   return jresult;
62644 }
62645
62646
62647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62648   int jresult ;
62649   int result;
62650
62651   {
62652     try {
62653       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62654     } catch (std::out_of_range& e) {
62655       {
62656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62657       };
62658     } catch (std::exception& e) {
62659       {
62660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62661       };
62662     } catch (Dali::DaliException e) {
62663       {
62664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62665       };
62666     } catch (...) {
62667       {
62668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62669       };
62670     }
62671   }
62672
62673   jresult = (int)result;
62674   return jresult;
62675 }
62676
62677
62678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62679   int jresult ;
62680   int result;
62681
62682   {
62683     try {
62684       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62685     } catch (std::out_of_range& e) {
62686       {
62687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62688       };
62689     } catch (std::exception& e) {
62690       {
62691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62692       };
62693     } catch (Dali::DaliException e) {
62694       {
62695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62696       };
62697     } catch (...) {
62698       {
62699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62700       };
62701     }
62702   }
62703
62704   jresult = (int)result;
62705   return jresult;
62706 }
62707
62708
62709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62710   int jresult ;
62711   int result;
62712
62713   {
62714     try {
62715       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62716     } catch (std::out_of_range& e) {
62717       {
62718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62719       };
62720     } catch (std::exception& e) {
62721       {
62722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62723       };
62724     } catch (Dali::DaliException e) {
62725       {
62726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62727       };
62728     } catch (...) {
62729       {
62730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62731       };
62732     }
62733   }
62734
62735   jresult = (int)result;
62736   return jresult;
62737 }
62738
62739
62740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62741   int jresult ;
62742   int result;
62743
62744   {
62745     try {
62746       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62747     } catch (std::out_of_range& e) {
62748       {
62749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62750       };
62751     } catch (std::exception& e) {
62752       {
62753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62754       };
62755     } catch (Dali::DaliException e) {
62756       {
62757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62758       };
62759     } catch (...) {
62760       {
62761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62762       };
62763     }
62764   }
62765
62766   jresult = (int)result;
62767   return jresult;
62768 }
62769
62770
62771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62772   int jresult ;
62773   int result;
62774
62775   {
62776     try {
62777       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62778     } catch (std::out_of_range& e) {
62779       {
62780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62781       };
62782     } catch (std::exception& e) {
62783       {
62784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62785       };
62786     } catch (Dali::DaliException e) {
62787       {
62788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62789       };
62790     } catch (...) {
62791       {
62792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62793       };
62794     }
62795   }
62796
62797   jresult = (int)result;
62798   return jresult;
62799 }
62800
62801
62802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62803   int jresult ;
62804   int result;
62805
62806   {
62807     try {
62808       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62809     } catch (std::out_of_range& e) {
62810       {
62811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62812       };
62813     } catch (std::exception& e) {
62814       {
62815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62816       };
62817     } catch (Dali::DaliException e) {
62818       {
62819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62820       };
62821     } catch (...) {
62822       {
62823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62824       };
62825     }
62826   }
62827
62828   jresult = (int)result;
62829   return jresult;
62830 }
62831
62832
62833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62834   int jresult ;
62835   int result;
62836
62837   {
62838     try {
62839       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62840     } catch (std::out_of_range& e) {
62841       {
62842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62843       };
62844     } catch (std::exception& e) {
62845       {
62846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62847       };
62848     } catch (Dali::DaliException e) {
62849       {
62850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62851       };
62852     } catch (...) {
62853       {
62854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62855       };
62856     }
62857   }
62858
62859   jresult = (int)result;
62860   return jresult;
62861 }
62862
62863
62864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62865   int jresult ;
62866   int result;
62867
62868   {
62869     try {
62870       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62871     } catch (std::out_of_range& e) {
62872       {
62873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62874       };
62875     } catch (std::exception& e) {
62876       {
62877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62878       };
62879     } catch (Dali::DaliException e) {
62880       {
62881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62882       };
62883     } catch (...) {
62884       {
62885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62886       };
62887     }
62888   }
62889
62890   jresult = (int)result;
62891   return jresult;
62892 }
62893
62894
62895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62896   int jresult ;
62897   int result;
62898
62899   {
62900     try {
62901       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62902     } catch (std::out_of_range& e) {
62903       {
62904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62905       };
62906     } catch (std::exception& e) {
62907       {
62908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62909       };
62910     } catch (Dali::DaliException e) {
62911       {
62912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62913       };
62914     } catch (...) {
62915       {
62916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62917       };
62918     }
62919   }
62920
62921   jresult = (int)result;
62922   return jresult;
62923 }
62924
62925
62926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62927   int jresult ;
62928   int result;
62929
62930   {
62931     try {
62932       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62933     } catch (std::out_of_range& e) {
62934       {
62935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62936       };
62937     } catch (std::exception& e) {
62938       {
62939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62940       };
62941     } catch (Dali::DaliException e) {
62942       {
62943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62944       };
62945     } catch (...) {
62946       {
62947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62948       };
62949     }
62950   }
62951
62952   jresult = (int)result;
62953   return jresult;
62954 }
62955
62956
62957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62958   void * jresult ;
62959   Dali::Toolkit::Control result;
62960
62961   {
62962     try {
62963       result = Dali::Toolkit::Internal::Control::New();
62964     } catch (std::out_of_range& e) {
62965       {
62966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62967       };
62968     } catch (std::exception& e) {
62969       {
62970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62971       };
62972     } catch (Dali::DaliException e) {
62973       {
62974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62975       };
62976     } catch (...) {
62977       {
62978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62979       };
62980     }
62981   }
62982
62983   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62984   return jresult;
62985 }
62986
62987
62988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
62989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62990   std::string *arg2 = 0 ;
62991
62992   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62993   if (!jarg2) {
62994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62995     return ;
62996   }
62997   std::string arg2_str(jarg2);
62998   arg2 = &arg2_str;
62999   {
63000     try {
63001       (arg1)->SetStyleName((std::string const &)*arg2);
63002     } catch (std::out_of_range& e) {
63003       {
63004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63005       };
63006     } catch (std::exception& e) {
63007       {
63008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63009       };
63010     } catch (Dali::DaliException e) {
63011       {
63012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63013       };
63014     } catch (...) {
63015       {
63016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63017       };
63018     }
63019   }
63020
63021
63022   //argout typemap for const std::string&
63023
63024 }
63025
63026
63027 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63028   char * jresult ;
63029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63030   std::string *result = 0 ;
63031
63032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63033   {
63034     try {
63035       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63036     } catch (std::out_of_range& e) {
63037       {
63038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63039       };
63040     } catch (std::exception& e) {
63041       {
63042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63043       };
63044     } catch (Dali::DaliException e) {
63045       {
63046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63047       };
63048     } catch (...) {
63049       {
63050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63051       };
63052     }
63053   }
63054
63055   jresult = SWIG_csharp_string_callback(result->c_str());
63056   return jresult;
63057 }
63058
63059
63060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63062   Dali::Vector4 *arg2 = 0 ;
63063
63064   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63065   arg2 = (Dali::Vector4 *)jarg2;
63066   if (!arg2) {
63067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63068     return ;
63069   }
63070   {
63071     try {
63072       (arg1)->SetBackgroundColor((Dali::Vector4 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
63094
63095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63096   void * jresult ;
63097   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63098   Dali::Vector4 result;
63099
63100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63101   {
63102     try {
63103       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63104     } catch (std::out_of_range& e) {
63105       {
63106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63107       };
63108     } catch (std::exception& e) {
63109       {
63110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63111       };
63112     } catch (Dali::DaliException e) {
63113       {
63114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63115       };
63116     } catch (...) {
63117       {
63118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63119       };
63120     }
63121   }
63122
63123   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63124   return jresult;
63125 }
63126
63127
63128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63130   Dali::Image arg2 ;
63131   Dali::Image *argp2 ;
63132
63133   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63134   argp2 = (Dali::Image *)jarg2;
63135   if (!argp2) {
63136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63137     return ;
63138   }
63139   arg2 = *argp2;
63140   {
63141     try {
63142       (arg1)->SetBackgroundImage(arg2);
63143     } catch (std::out_of_range& e) {
63144       {
63145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63146       };
63147     } catch (std::exception& e) {
63148       {
63149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63150       };
63151     } catch (Dali::DaliException e) {
63152       {
63153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63154       };
63155     } catch (...) {
63156       {
63157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63158       };
63159     }
63160   }
63161
63162 }
63163
63164
63165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63167   Dali::Property::Map *arg2 = 0 ;
63168
63169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63170   arg2 = (Dali::Property::Map *)jarg2;
63171   if (!arg2) {
63172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63173     return ;
63174   }
63175   {
63176     try {
63177       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63178     } catch (std::out_of_range& e) {
63179       {
63180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63181       };
63182     } catch (std::exception& e) {
63183       {
63184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63185       };
63186     } catch (Dali::DaliException e) {
63187       {
63188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63189       };
63190     } catch (...) {
63191       {
63192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63193       };
63194     }
63195   }
63196
63197 }
63198
63199
63200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63202
63203   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63204   {
63205     try {
63206       (arg1)->ClearBackground();
63207     } catch (std::out_of_range& e) {
63208       {
63209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63210       };
63211     } catch (std::exception& e) {
63212       {
63213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63214       };
63215     } catch (Dali::DaliException e) {
63216       {
63217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63218       };
63219     } catch (...) {
63220       {
63221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63222       };
63223     }
63224   }
63225
63226 }
63227
63228
63229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63230   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63231   Dali::Gesture::Type arg2 ;
63232
63233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63234   arg2 = (Dali::Gesture::Type)jarg2;
63235   {
63236     try {
63237       (arg1)->EnableGestureDetection(arg2);
63238     } catch (std::out_of_range& e) {
63239       {
63240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63241       };
63242     } catch (std::exception& e) {
63243       {
63244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63245       };
63246     } catch (Dali::DaliException e) {
63247       {
63248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63249       };
63250     } catch (...) {
63251       {
63252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63253       };
63254     }
63255   }
63256
63257 }
63258
63259
63260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63261   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63262   Dali::Gesture::Type arg2 ;
63263
63264   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63265   arg2 = (Dali::Gesture::Type)jarg2;
63266   {
63267     try {
63268       (arg1)->DisableGestureDetection(arg2);
63269     } catch (std::out_of_range& e) {
63270       {
63271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63272       };
63273     } catch (std::exception& e) {
63274       {
63275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63276       };
63277     } catch (Dali::DaliException e) {
63278       {
63279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63280       };
63281     } catch (...) {
63282       {
63283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63284       };
63285     }
63286   }
63287
63288 }
63289
63290
63291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63292   void * jresult ;
63293   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63294   Dali::PinchGestureDetector result;
63295
63296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63297   {
63298     try {
63299       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63300     } catch (std::out_of_range& e) {
63301       {
63302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63303       };
63304     } catch (std::exception& e) {
63305       {
63306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63307       };
63308     } catch (Dali::DaliException e) {
63309       {
63310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63311       };
63312     } catch (...) {
63313       {
63314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63315       };
63316     }
63317   }
63318
63319   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63320   return jresult;
63321 }
63322
63323
63324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63325   void * jresult ;
63326   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63327   Dali::PanGestureDetector result;
63328
63329   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63330   {
63331     try {
63332       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63333     } catch (std::out_of_range& e) {
63334       {
63335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63336       };
63337     } catch (std::exception& e) {
63338       {
63339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63340       };
63341     } catch (Dali::DaliException e) {
63342       {
63343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63344       };
63345     } catch (...) {
63346       {
63347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63348       };
63349     }
63350   }
63351
63352   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63353   return jresult;
63354 }
63355
63356
63357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63358   void * jresult ;
63359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63360   Dali::TapGestureDetector result;
63361
63362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63363   {
63364     try {
63365       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63366     } catch (std::out_of_range& e) {
63367       {
63368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63369       };
63370     } catch (std::exception& e) {
63371       {
63372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63373       };
63374     } catch (Dali::DaliException e) {
63375       {
63376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63377       };
63378     } catch (...) {
63379       {
63380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63381       };
63382     }
63383   }
63384
63385   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63386   return jresult;
63387 }
63388
63389
63390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63391   void * jresult ;
63392   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63393   Dali::LongPressGestureDetector result;
63394
63395   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63396   {
63397     try {
63398       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63399     } catch (std::out_of_range& e) {
63400       {
63401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63402       };
63403     } catch (std::exception& e) {
63404       {
63405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63406       };
63407     } catch (Dali::DaliException e) {
63408       {
63409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63410       };
63411     } catch (...) {
63412       {
63413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63414       };
63415     }
63416   }
63417
63418   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63419   return jresult;
63420 }
63421
63422
63423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63424   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63425   bool arg2 ;
63426
63427   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63428   arg2 = jarg2 ? true : false;
63429   {
63430     try {
63431       (arg1)->SetKeyboardNavigationSupport(arg2);
63432     } catch (std::out_of_range& e) {
63433       {
63434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63435       };
63436     } catch (std::exception& e) {
63437       {
63438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63439       };
63440     } catch (Dali::DaliException e) {
63441       {
63442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63443       };
63444     } catch (...) {
63445       {
63446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63447       };
63448     }
63449   }
63450
63451 }
63452
63453
63454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63455   unsigned int jresult ;
63456   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63457   bool result;
63458
63459   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63460   {
63461     try {
63462       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63463     } catch (std::out_of_range& e) {
63464       {
63465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63466       };
63467     } catch (std::exception& e) {
63468       {
63469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63470       };
63471     } catch (Dali::DaliException e) {
63472       {
63473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63474       };
63475     } catch (...) {
63476       {
63477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63478       };
63479     }
63480   }
63481
63482   jresult = result;
63483   return jresult;
63484 }
63485
63486
63487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63488   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63489
63490   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63491   {
63492     try {
63493       (arg1)->SetKeyInputFocus();
63494     } catch (std::out_of_range& e) {
63495       {
63496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63497       };
63498     } catch (std::exception& e) {
63499       {
63500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63501       };
63502     } catch (Dali::DaliException e) {
63503       {
63504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63505       };
63506     } catch (...) {
63507       {
63508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63509       };
63510     }
63511   }
63512
63513 }
63514
63515
63516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63517   unsigned int jresult ;
63518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63519   bool result;
63520
63521   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63522   {
63523     try {
63524       result = (bool)(arg1)->HasKeyInputFocus();
63525     } catch (std::out_of_range& e) {
63526       {
63527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63528       };
63529     } catch (std::exception& e) {
63530       {
63531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63532       };
63533     } catch (Dali::DaliException e) {
63534       {
63535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63536       };
63537     } catch (...) {
63538       {
63539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63540       };
63541     }
63542   }
63543
63544   jresult = result;
63545   return jresult;
63546 }
63547
63548
63549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63551
63552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63553   {
63554     try {
63555       (arg1)->ClearKeyInputFocus();
63556     } catch (std::out_of_range& e) {
63557       {
63558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63559       };
63560     } catch (std::exception& e) {
63561       {
63562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63563       };
63564     } catch (Dali::DaliException e) {
63565       {
63566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63567       };
63568     } catch (...) {
63569       {
63570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63571       };
63572     }
63573   }
63574
63575 }
63576
63577
63578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63579   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63580   bool arg2 ;
63581
63582   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63583   arg2 = jarg2 ? true : false;
63584   {
63585     try {
63586       (arg1)->SetAsKeyboardFocusGroup(arg2);
63587     } catch (std::out_of_range& e) {
63588       {
63589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63590       };
63591     } catch (std::exception& e) {
63592       {
63593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63594       };
63595     } catch (Dali::DaliException e) {
63596       {
63597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63598       };
63599     } catch (...) {
63600       {
63601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63602       };
63603     }
63604   }
63605
63606 }
63607
63608
63609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63610   unsigned int jresult ;
63611   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63612   bool result;
63613
63614   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63615   {
63616     try {
63617       result = (bool)(arg1)->IsKeyboardFocusGroup();
63618     } catch (std::out_of_range& e) {
63619       {
63620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63621       };
63622     } catch (std::exception& e) {
63623       {
63624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63625       };
63626     } catch (Dali::DaliException e) {
63627       {
63628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63629       };
63630     } catch (...) {
63631       {
63632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63633       };
63634     }
63635   }
63636
63637   jresult = result;
63638   return jresult;
63639 }
63640
63641
63642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63643   void * jresult ;
63644   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63645   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63646
63647   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63648   {
63649     try {
63650       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63651     } catch (std::out_of_range& e) {
63652       {
63653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63654       };
63655     } catch (std::exception& e) {
63656       {
63657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63658       };
63659     } catch (Dali::DaliException e) {
63660       {
63661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63662       };
63663     } catch (...) {
63664       {
63665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63666       };
63667     }
63668   }
63669
63670   jresult = (void *)result;
63671   return jresult;
63672 }
63673
63674
63675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63676   void * jresult ;
63677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63678   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63679
63680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63681   {
63682     try {
63683       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63684     } catch (std::out_of_range& e) {
63685       {
63686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63687       };
63688     } catch (std::exception& e) {
63689       {
63690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63691       };
63692     } catch (Dali::DaliException e) {
63693       {
63694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63695       };
63696     } catch (...) {
63697       {
63698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63699       };
63700     }
63701   }
63702
63703   jresult = (void *)result;
63704   return jresult;
63705 }
63706
63707
63708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63709   void * jresult ;
63710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63711   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63712
63713   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63714   {
63715     try {
63716       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63717     } catch (std::out_of_range& e) {
63718       {
63719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63720       };
63721     } catch (std::exception& e) {
63722       {
63723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63724       };
63725     } catch (Dali::DaliException e) {
63726       {
63727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63728       };
63729     } catch (...) {
63730       {
63731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63732       };
63733     }
63734   }
63735
63736   jresult = (void *)result;
63737   return jresult;
63738 }
63739
63740
63741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63743   int arg2 ;
63744   SwigDirector_ViewImpl *darg = 0;
63745
63746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63747   arg2 = (int)jarg2;
63748   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63749   if(!darg) {
63750     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63751     return;
63752   }
63753   {
63754     try {
63755       if(darg) {
63756         (darg)->OnStageConnection(arg2);
63757       }
63758     } catch (std::out_of_range& e) {
63759       {
63760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63761       };
63762     } catch (std::exception& e) {
63763       {
63764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63765       };
63766     } catch (Dali::DaliException e) {
63767       {
63768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63769       };
63770     } catch (...) {
63771       {
63772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63773       };
63774     }
63775   }
63776
63777 }
63778
63779
63780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63781   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63782   int arg2 ;
63783   SwigDirector_ViewImpl *darg = 0;
63784
63785   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63786   arg2 = (int)jarg2;
63787   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63788   if(!darg) {
63789     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63790     return;
63791   }
63792   {
63793     try {
63794       if(darg) {
63795         (darg)->OnStageConnectionSwigPublic(arg2);
63796       }
63797     } catch (std::out_of_range& e) {
63798       {
63799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63800       };
63801     } catch (std::exception& e) {
63802       {
63803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63804       };
63805     } catch (Dali::DaliException e) {
63806       {
63807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63808       };
63809     } catch (...) {
63810       {
63811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63812       };
63813     }
63814   }
63815
63816 }
63817
63818
63819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63821   SwigDirector_ViewImpl *darg = 0;
63822
63823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63824   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63825   if(!darg) {
63826     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63827     return;
63828   }
63829   {
63830     try {
63831       if(darg) {
63832         (darg)->OnStageDisconnection();
63833       }
63834     } catch (std::out_of_range& e) {
63835       {
63836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63837       };
63838     } catch (std::exception& e) {
63839       {
63840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63841       };
63842     } catch (Dali::DaliException e) {
63843       {
63844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63845       };
63846     } catch (...) {
63847       {
63848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63849       };
63850     }
63851   }
63852
63853 }
63854
63855
63856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63857   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63858   SwigDirector_ViewImpl *darg = 0;
63859
63860   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63861   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63862   if(!darg) {
63863     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63864     return;
63865   }
63866   {
63867     try {
63868       if(darg) {
63869         (darg)->OnStageDisconnectionSwigPublic();
63870       }
63871     } catch (std::out_of_range& e) {
63872       {
63873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63874       };
63875     } catch (std::exception& e) {
63876       {
63877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63878       };
63879     } catch (Dali::DaliException e) {
63880       {
63881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63882       };
63883     } catch (...) {
63884       {
63885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63886       };
63887     }
63888   }
63889
63890 }
63891
63892
63893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63894   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63895   Dali::Actor *arg2 = 0 ;
63896   SwigDirector_ViewImpl *darg = 0;
63897
63898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63899   arg2 = (Dali::Actor *)jarg2;
63900   if (!arg2) {
63901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63902     return ;
63903   }
63904   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63905   if(!darg) {
63906     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63907     return;
63908   }
63909   {
63910     try {
63911       if(darg) {
63912         (darg)->OnChildAdd(*arg2);
63913       }
63914     } catch (std::out_of_range& e) {
63915       {
63916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63917       };
63918     } catch (std::exception& e) {
63919       {
63920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63921       };
63922     } catch (Dali::DaliException e) {
63923       {
63924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63925       };
63926     } catch (...) {
63927       {
63928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63929       };
63930     }
63931   }
63932
63933 }
63934
63935
63936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63938   Dali::Actor *arg2 = 0 ;
63939   SwigDirector_ViewImpl *darg = 0;
63940
63941   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63942   arg2 = (Dali::Actor *)jarg2;
63943   if (!arg2) {
63944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63945     return ;
63946   }
63947   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63948   if(!darg) {
63949     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63950     return;
63951   }
63952   {
63953     try {
63954       if(darg) {
63955           (darg)->OnChildAddSwigPublic(*arg2);
63956       }
63957     } catch (std::out_of_range& e) {
63958       {
63959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63960       };
63961     } catch (std::exception& e) {
63962       {
63963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63964       };
63965     } catch (Dali::DaliException e) {
63966       {
63967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63968       };
63969     } catch (...) {
63970       {
63971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63972       };
63973     }
63974   }
63975
63976 }
63977
63978
63979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
63980   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63981   Dali::Actor *arg2 = 0 ;
63982   SwigDirector_ViewImpl *darg = 0;
63983
63984   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63985   arg2 = (Dali::Actor *)jarg2;
63986   if (!arg2) {
63987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63988     return ;
63989   }
63990   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63991   if(!darg) {
63992     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63993     return;
63994   }
63995   {
63996     try {
63997       if(darg) {
63998         (darg)->OnChildRemove(*arg2);
63999       }
64000     } catch (std::out_of_range& e) {
64001       {
64002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64003       };
64004     } catch (std::exception& e) {
64005       {
64006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64007       };
64008     } catch (Dali::DaliException e) {
64009       {
64010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64011       };
64012     } catch (...) {
64013       {
64014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64015       };
64016     }
64017   }
64018
64019 }
64020
64021
64022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64024   Dali::Actor *arg2 = 0 ;
64025   SwigDirector_ViewImpl *darg = 0;
64026
64027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64028   arg2 = (Dali::Actor *)jarg2;
64029   if (!arg2) {
64030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64031     return ;
64032   }
64033   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64034   if(!darg) {
64035     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64036     return;
64037   }
64038   {
64039     try {
64040       if(darg) {
64041         (darg)->OnChildRemoveSwigPublic(*arg2);
64042       }
64043     } catch (std::out_of_range& e) {
64044       {
64045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64046       };
64047     } catch (std::exception& e) {
64048       {
64049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64050       };
64051     } catch (Dali::DaliException e) {
64052       {
64053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64054       };
64055     } catch (...) {
64056       {
64057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64058       };
64059     }
64060   }
64061
64062 }
64063
64064
64065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64067   Dali::Property::Index arg2 ;
64068   Dali::Property::Value arg3 ;
64069   Dali::Property::Value *argp3 ;
64070   SwigDirector_ViewImpl *darg = 0;
64071
64072   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64073   arg2 = (Dali::Property::Index)jarg2;
64074   argp3 = (Dali::Property::Value *)jarg3;
64075   if (!argp3) {
64076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64077     return ;
64078   }
64079   arg3 = *argp3;
64080   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64081   if (!darg) {
64082     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64083     return;
64084   }
64085   {
64086     try {
64087       (darg)->OnPropertySet(arg2,arg3);
64088     } catch (std::out_of_range& e) {
64089       {
64090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64091       };
64092     } catch (std::exception& e) {
64093       {
64094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64095       };
64096     } catch (Dali::DaliException e) {
64097       {
64098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64099       };
64100     } catch (...) {
64101       {
64102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64103       };
64104     }
64105   }
64106
64107 }
64108
64109
64110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64112   Dali::Property::Index arg2 ;
64113   Dali::Property::Value arg3 ;
64114   Dali::Property::Value *argp3 ;
64115   SwigDirector_ViewImpl *darg = 0;
64116
64117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64118   arg2 = (Dali::Property::Index)jarg2;
64119   argp3 = (Dali::Property::Value *)jarg3;
64120   if (!argp3) {
64121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64122     return ;
64123   }
64124   arg3 = *argp3;
64125   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64126   if (!darg) {
64127     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64128     return;
64129   }
64130   {
64131     try {
64132       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64133     } catch (std::out_of_range& e) {
64134       {
64135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64136       };
64137     } catch (std::exception& e) {
64138       {
64139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64140       };
64141     } catch (Dali::DaliException e) {
64142       {
64143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64144       };
64145     } catch (...) {
64146       {
64147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64148       };
64149     }
64150   }
64151
64152 }
64153
64154
64155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64157   Dali::Vector3 *arg2 = 0 ;
64158   SwigDirector_ViewImpl *darg = 0;
64159
64160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64161   arg2 = (Dali::Vector3 *)jarg2;
64162   if (!arg2) {
64163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64164     return ;
64165   }
64166   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64167   if (!darg) {
64168     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64169     return;
64170   }
64171   {
64172     try {
64173       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64174     } catch (std::out_of_range& e) {
64175       {
64176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64177       };
64178     } catch (std::exception& e) {
64179       {
64180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64181       };
64182     } catch (Dali::DaliException e) {
64183       {
64184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64185       };
64186     } catch (...) {
64187       {
64188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64189       };
64190     }
64191   }
64192
64193 }
64194
64195
64196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64197   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64198   Dali::Vector3 *arg2 = 0 ;
64199   SwigDirector_ViewImpl *darg = 0;
64200
64201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64202   arg2 = (Dali::Vector3 *)jarg2;
64203   if (!arg2) {
64204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64205     return ;
64206   }
64207   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64208   if (!darg) {
64209     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64210     return;
64211   }
64212   {
64213     try {
64214       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64215     } catch (std::out_of_range& e) {
64216       {
64217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64218       };
64219     } catch (std::exception& e) {
64220       {
64221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64222       };
64223     } catch (Dali::DaliException e) {
64224       {
64225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64226       };
64227     } catch (...) {
64228       {
64229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64230       };
64231     }
64232   }
64233
64234 }
64235
64236
64237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64239   Dali::Animation *arg2 = 0 ;
64240   Dali::Vector3 *arg3 = 0 ;
64241   SwigDirector_ViewImpl *darg = 0;
64242
64243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64244   arg2 = (Dali::Animation *)jarg2;
64245   if (!arg2) {
64246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64247     return ;
64248   }
64249   arg3 = (Dali::Vector3 *)jarg3;
64250   if (!arg3) {
64251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64252     return ;
64253   }
64254   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64255   if (!darg) {
64256     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64257     return;
64258   }
64259   {
64260     try {
64261       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64262     } catch (std::out_of_range& e) {
64263       {
64264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64265       };
64266     } catch (std::exception& e) {
64267       {
64268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64269       };
64270     } catch (Dali::DaliException e) {
64271       {
64272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64273       };
64274     } catch (...) {
64275       {
64276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64277       };
64278     }
64279   }
64280
64281 }
64282
64283
64284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64285   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64286   Dali::Animation *arg2 = 0 ;
64287   Dali::Vector3 *arg3 = 0 ;
64288   SwigDirector_ViewImpl *darg = 0;
64289
64290   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64291   arg2 = (Dali::Animation *)jarg2;
64292   if (!arg2) {
64293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64294     return ;
64295   }
64296   arg3 = (Dali::Vector3 *)jarg3;
64297   if (!arg3) {
64298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64299     return ;
64300   }
64301   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64302   if (!darg) {
64303     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64304     return;
64305   }
64306   {
64307     try {
64308       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64309     } catch (std::out_of_range& e) {
64310       {
64311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64312       };
64313     } catch (std::exception& e) {
64314       {
64315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64316       };
64317     } catch (Dali::DaliException e) {
64318       {
64319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64320       };
64321     } catch (...) {
64322       {
64323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64324       };
64325     }
64326   }
64327
64328 }
64329
64330
64331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64332   unsigned int jresult ;
64333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64334   Dali::TouchEvent *arg2 = 0 ;
64335   SwigDirector_ViewImpl *darg = 0;
64336   bool result;
64337
64338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64339   arg2 = (Dali::TouchEvent *)jarg2;
64340   if (!arg2) {
64341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64342     return 0;
64343   }
64344   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64345   if (!darg) {
64346     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64347     return 0;
64348   }
64349   {
64350     try {
64351       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64352     } catch (std::out_of_range& e) {
64353       {
64354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64355       };
64356     } catch (std::exception& e) {
64357       {
64358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64359       };
64360     } catch (Dali::DaliException e) {
64361       {
64362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64363       };
64364     } catch (...) {
64365       {
64366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64367       };
64368     }
64369   }
64370
64371   jresult = result;
64372   return jresult;
64373 }
64374
64375
64376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64377   unsigned int jresult ;
64378   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64379   Dali::TouchEvent *arg2 = 0 ;
64380   SwigDirector_ViewImpl *darg = 0;
64381   bool result;
64382
64383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64384   arg2 = (Dali::TouchEvent *)jarg2;
64385   if (!arg2) {
64386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64387     return 0;
64388   }
64389   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64390   if (!darg) {
64391     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64392     return 0;
64393   }
64394   {
64395     try {
64396       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64397     } catch (std::out_of_range& e) {
64398       {
64399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64400       };
64401     } catch (std::exception& e) {
64402       {
64403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64404       };
64405     } catch (Dali::DaliException e) {
64406       {
64407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64408       };
64409     } catch (...) {
64410       {
64411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64412       };
64413     }
64414   }
64415
64416   jresult = result;
64417   return jresult;
64418 }
64419
64420
64421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64422   unsigned int jresult ;
64423   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64424   Dali::HoverEvent *arg2 = 0 ;
64425   SwigDirector_ViewImpl *darg = 0;
64426   bool result;
64427
64428   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64429   arg2 = (Dali::HoverEvent *)jarg2;
64430   if (!arg2) {
64431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64432     return 0;
64433   }
64434   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64435   if (!darg) {
64436     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64437     return 0;
64438   }
64439   {
64440     try {
64441       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64442     } catch (std::out_of_range& e) {
64443       {
64444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64445       };
64446     } catch (std::exception& e) {
64447       {
64448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64449       };
64450     } catch (Dali::DaliException e) {
64451       {
64452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64453       };
64454     } catch (...) {
64455       {
64456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64457       };
64458     }
64459   }
64460
64461   jresult = result;
64462   return jresult;
64463 }
64464
64465
64466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64467   unsigned int jresult ;
64468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64469   Dali::HoverEvent *arg2 = 0 ;
64470   SwigDirector_ViewImpl *darg = 0;
64471   bool result;
64472
64473   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64474   arg2 = (Dali::HoverEvent *)jarg2;
64475   if (!arg2) {
64476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64477     return 0;
64478   }
64479   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64480   if (!darg) {
64481     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64482     return 0;
64483   }
64484   {
64485     try {
64486       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64487     } catch (std::out_of_range& e) {
64488       {
64489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64490       };
64491     } catch (std::exception& e) {
64492       {
64493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64494       };
64495     } catch (Dali::DaliException e) {
64496       {
64497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64498       };
64499     } catch (...) {
64500       {
64501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64502       };
64503     }
64504   }
64505
64506   jresult = result;
64507   return jresult;
64508 }
64509
64510
64511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64512   unsigned int jresult ;
64513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64514   Dali::KeyEvent *arg2 = 0 ;
64515   SwigDirector_ViewImpl *darg = 0;
64516   bool result;
64517
64518   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64519   arg2 = (Dali::KeyEvent *)jarg2;
64520   if (!arg2) {
64521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64522     return 0;
64523   }
64524   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64525   if (!darg) {
64526     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64527     return 0;
64528   }
64529   {
64530     try {
64531       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64532     } catch (std::out_of_range& e) {
64533       {
64534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64535       };
64536     } catch (std::exception& e) {
64537       {
64538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64539       };
64540     } catch (Dali::DaliException e) {
64541       {
64542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64543       };
64544     } catch (...) {
64545       {
64546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64547       };
64548     }
64549   }
64550
64551   jresult = result;
64552   return jresult;
64553 }
64554
64555
64556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64557   unsigned int jresult ;
64558   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64559   Dali::KeyEvent *arg2 = 0 ;
64560   SwigDirector_ViewImpl *darg = 0;
64561   bool result;
64562
64563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64564   arg2 = (Dali::KeyEvent *)jarg2;
64565   if (!arg2) {
64566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64567     return 0;
64568   }
64569   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64570   if (!darg) {
64571     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64572     return 0;
64573   }
64574   {
64575     try {
64576       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64577     } catch (std::out_of_range& e) {
64578       {
64579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64580       };
64581     } catch (std::exception& e) {
64582       {
64583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64584       };
64585     } catch (Dali::DaliException e) {
64586       {
64587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64588       };
64589     } catch (...) {
64590       {
64591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64592       };
64593     }
64594   }
64595
64596   jresult = result;
64597   return jresult;
64598 }
64599
64600
64601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64602   unsigned int jresult ;
64603   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64604   Dali::WheelEvent *arg2 = 0 ;
64605   SwigDirector_ViewImpl *darg = 0;
64606   bool result;
64607
64608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64609   arg2 = (Dali::WheelEvent *)jarg2;
64610   if (!arg2) {
64611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64612     return 0;
64613   }
64614   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64615   if (!darg) {
64616     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64617     return 0;
64618   }
64619   {
64620     try {
64621       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64622     } catch (std::out_of_range& e) {
64623       {
64624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64625       };
64626     } catch (std::exception& e) {
64627       {
64628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64629       };
64630     } catch (Dali::DaliException e) {
64631       {
64632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64633       };
64634     } catch (...) {
64635       {
64636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64637       };
64638     }
64639   }
64640
64641   jresult = result;
64642   return jresult;
64643 }
64644
64645
64646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64647   unsigned int jresult ;
64648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64649   Dali::WheelEvent *arg2 = 0 ;
64650   SwigDirector_ViewImpl *darg = 0;
64651   bool result;
64652
64653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64654   arg2 = (Dali::WheelEvent *)jarg2;
64655   if (!arg2) {
64656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64657     return 0;
64658   }
64659   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64660   if (!darg) {
64661     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64662     return 0;
64663   }
64664   {
64665     try {
64666       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64667     } catch (std::out_of_range& e) {
64668       {
64669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64670       };
64671     } catch (std::exception& e) {
64672       {
64673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64674       };
64675     } catch (Dali::DaliException e) {
64676       {
64677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64678       };
64679     } catch (...) {
64680       {
64681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64682       };
64683     }
64684   }
64685
64686   jresult = result;
64687   return jresult;
64688 }
64689
64690
64691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64692   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64693   Dali::Vector2 *arg2 = 0 ;
64694   Dali::RelayoutContainer *arg3 = 0 ;
64695   SwigDirector_ViewImpl *darg = 0;
64696
64697   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64698   arg2 = (Dali::Vector2 *)jarg2;
64699   if (!arg2) {
64700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64701     return ;
64702   }
64703   arg3 = (Dali::RelayoutContainer *)jarg3;
64704   if (!arg3) {
64705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64706     return ;
64707   }
64708   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64709   if (!darg) {
64710     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64711     return;
64712   }
64713   {
64714     try {
64715       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64716     } catch (std::out_of_range& e) {
64717       {
64718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64719       };
64720     } catch (std::exception& e) {
64721       {
64722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64723       };
64724     } catch (Dali::DaliException e) {
64725       {
64726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64727       };
64728     } catch (...) {
64729       {
64730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64731       };
64732     }
64733   }
64734
64735 }
64736
64737
64738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64740   Dali::Vector2 *arg2 = 0 ;
64741   Dali::RelayoutContainer *arg3 = 0 ;
64742   SwigDirector_ViewImpl *darg = 0;
64743
64744   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64745   arg2 = (Dali::Vector2 *)jarg2;
64746   if (!arg2) {
64747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64748     return ;
64749   }
64750   arg3 = (Dali::RelayoutContainer *)jarg3;
64751   if (!arg3) {
64752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64753     return ;
64754   }
64755   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64756   if (!darg) {
64757     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64758     return;
64759   }
64760   {
64761     try {
64762       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64763     } catch (std::out_of_range& e) {
64764       {
64765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64766       };
64767     } catch (std::exception& e) {
64768       {
64769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64770       };
64771     } catch (Dali::DaliException e) {
64772       {
64773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64774       };
64775     } catch (...) {
64776       {
64777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64778       };
64779     }
64780   }
64781
64782 }
64783
64784
64785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64786   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64787   Dali::ResizePolicy::Type arg2 ;
64788   Dali::Dimension::Type arg3 ;
64789   SwigDirector_ViewImpl *darg = 0;
64790
64791   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64792   arg2 = (Dali::ResizePolicy::Type)jarg2;
64793   arg3 = (Dali::Dimension::Type)jarg3;
64794   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64795   if (!darg) {
64796     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64797     return;
64798   }
64799   {
64800     try {
64801       (darg)->OnSetResizePolicy(arg2,arg3);
64802     } catch (std::out_of_range& e) {
64803       {
64804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64805       };
64806     } catch (std::exception& e) {
64807       {
64808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64809       };
64810     } catch (Dali::DaliException e) {
64811       {
64812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64813       };
64814     } catch (...) {
64815       {
64816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64817       };
64818     }
64819   }
64820
64821 }
64822
64823
64824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64825   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64826   Dali::ResizePolicy::Type arg2 ;
64827   Dali::Dimension::Type arg3 ;
64828   SwigDirector_ViewImpl *darg = 0;
64829
64830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64831   arg2 = (Dali::ResizePolicy::Type)jarg2;
64832   arg3 = (Dali::Dimension::Type)jarg3;
64833   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64834   if (!darg) {
64835     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64836     return;
64837   }
64838   {
64839     try {
64840       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64841     } catch (std::out_of_range& e) {
64842       {
64843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64844       };
64845     } catch (std::exception& e) {
64846       {
64847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64848       };
64849     } catch (Dali::DaliException e) {
64850       {
64851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64852       };
64853     } catch (...) {
64854       {
64855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64856       };
64857     }
64858   }
64859
64860 }
64861
64862
64863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64864   void * jresult ;
64865   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64866   SwigDirector_ViewImpl *darg = 0;
64867   Dali::Vector3 result;
64868
64869   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64870   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64871   if (!darg) {
64872     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64873     return 0;
64874   }
64875   {
64876     try {
64877       result = (darg)->GetNaturalSize();
64878     } catch (std::out_of_range& e) {
64879       {
64880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64881       };
64882     } catch (std::exception& e) {
64883       {
64884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64885       };
64886     } catch (Dali::DaliException e) {
64887       {
64888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64889       };
64890     } catch (...) {
64891       {
64892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64893       };
64894     }
64895   }
64896
64897   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64898   return jresult;
64899 }
64900
64901
64902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64903   void * jresult ;
64904   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64905   SwigDirector_ViewImpl *darg = 0;
64906   Dali::Vector3 result;
64907
64908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64909   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64910   if (!darg) {
64911     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64912     return 0;
64913   }
64914   {
64915     try {
64916       result = (darg)->GetNaturalSizeSwigPublic();
64917     } catch (std::out_of_range& e) {
64918       {
64919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64920       };
64921     } catch (std::exception& e) {
64922       {
64923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64924       };
64925     } catch (Dali::DaliException e) {
64926       {
64927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64928       };
64929     } catch (...) {
64930       {
64931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64932       };
64933     }
64934   }
64935
64936   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64937   return jresult;
64938 }
64939
64940
64941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64942   float jresult ;
64943   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64944   Dali::Actor *arg2 = 0 ;
64945   Dali::Dimension::Type arg3 ;
64946   SwigDirector_ViewImpl *darg = 0;
64947   float result;
64948
64949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64950   arg2 = (Dali::Actor *)jarg2;
64951   if (!arg2) {
64952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64953     return 0;
64954   }
64955   arg3 = (Dali::Dimension::Type)jarg3;
64956   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64957   if (!darg) {
64958     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64959     return 0;
64960   }
64961   {
64962     try {
64963       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
64964     } catch (std::out_of_range& e) {
64965       {
64966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64967       };
64968     } catch (std::exception& e) {
64969       {
64970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64971       };
64972     } catch (Dali::DaliException e) {
64973       {
64974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64975       };
64976     } catch (...) {
64977       {
64978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64979       };
64980     }
64981   }
64982
64983   jresult = result;
64984   return jresult;
64985 }
64986
64987
64988 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
64989   float jresult ;
64990   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64991   Dali::Actor *arg2 = 0 ;
64992   Dali::Dimension::Type arg3 ;
64993   SwigDirector_ViewImpl *darg = 0;
64994   float result;
64995
64996   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64997   arg2 = (Dali::Actor *)jarg2;
64998   if (!arg2) {
64999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65000     return 0;
65001   }
65002   arg3 = (Dali::Dimension::Type)jarg3;
65003   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65004   if (!darg) {
65005     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65006     return 0;
65007   }
65008   {
65009     try {
65010       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65011     } catch (std::out_of_range& e) {
65012       {
65013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65014       };
65015     } catch (std::exception& e) {
65016       {
65017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65018       };
65019     } catch (Dali::DaliException e) {
65020       {
65021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65022       };
65023     } catch (...) {
65024       {
65025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65026       };
65027     }
65028   }
65029
65030   jresult = result;
65031   return jresult;
65032 }
65033
65034
65035 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65036   float jresult ;
65037   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65038   float arg2 ;
65039   SwigDirector_ViewImpl *darg = 0;
65040   float result;
65041
65042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65043   arg2 = (float)jarg2;
65044   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65045   if (!darg) {
65046     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65047     return 0;
65048   }
65049   {
65050     try {
65051       result = (float)(darg)->GetHeightForWidth(arg2);
65052     } catch (std::out_of_range& e) {
65053       {
65054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65055       };
65056     } catch (std::exception& e) {
65057       {
65058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65059       };
65060     } catch (Dali::DaliException e) {
65061       {
65062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65063       };
65064     } catch (...) {
65065       {
65066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65067       };
65068     }
65069   }
65070
65071   jresult = result;
65072   return jresult;
65073 }
65074
65075
65076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65077   float jresult ;
65078   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65079   float arg2 ;
65080   SwigDirector_ViewImpl *darg = 0;
65081   float result;
65082
65083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65084   arg2 = (float)jarg2;
65085   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65086   if (!darg) {
65087     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65088     return 0;
65089   }
65090   {
65091     try {
65092       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65093     } catch (std::out_of_range& e) {
65094       {
65095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65096       };
65097     } catch (std::exception& e) {
65098       {
65099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65100       };
65101     } catch (Dali::DaliException e) {
65102       {
65103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65104       };
65105     } catch (...) {
65106       {
65107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65108       };
65109     }
65110   }
65111
65112   jresult = result;
65113   return jresult;
65114 }
65115
65116
65117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65118   float jresult ;
65119   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65120   float arg2 ;
65121   SwigDirector_ViewImpl *darg = 0;
65122   float result;
65123
65124   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65125   arg2 = (float)jarg2;
65126   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65127   if (!darg) {
65128     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65129     return 0;
65130   }
65131   {
65132     try {
65133       result = (float)(darg)->GetWidthForHeight(arg2);
65134     } catch (std::out_of_range& e) {
65135       {
65136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65137       };
65138     } catch (std::exception& e) {
65139       {
65140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65141       };
65142     } catch (Dali::DaliException e) {
65143       {
65144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65145       };
65146     } catch (...) {
65147       {
65148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65149       };
65150     }
65151   }
65152
65153   jresult = result;
65154   return jresult;
65155 }
65156
65157
65158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65159   float jresult ;
65160   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65161   float arg2 ;
65162   SwigDirector_ViewImpl *darg = 0;
65163   float result;
65164
65165   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65166   arg2 = (float)jarg2;
65167   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65168   if (!darg) {
65169     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65170     return 0;
65171   }
65172   {
65173     try {
65174       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65175     } catch (std::out_of_range& e) {
65176       {
65177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65178       };
65179     } catch (std::exception& e) {
65180       {
65181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65182       };
65183     } catch (Dali::DaliException e) {
65184       {
65185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65186       };
65187     } catch (...) {
65188       {
65189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65190       };
65191     }
65192   }
65193
65194   jresult = result;
65195   return jresult;
65196 }
65197
65198
65199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65200   unsigned int jresult ;
65201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65202   Dali::Dimension::Type arg2 ;
65203   SwigDirector_ViewImpl *darg = 0;
65204   bool result;
65205
65206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65207   arg2 = (Dali::Dimension::Type)jarg2;
65208   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65209   if (!darg) {
65210     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65211     return 0;
65212   }
65213   {
65214     try {
65215       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65216     } catch (std::out_of_range& e) {
65217       {
65218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65219       };
65220     } catch (std::exception& e) {
65221       {
65222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65223       };
65224     } catch (Dali::DaliException e) {
65225       {
65226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65227       };
65228     } catch (...) {
65229       {
65230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65231       };
65232     }
65233   }
65234
65235   jresult = result;
65236   return jresult;
65237 }
65238
65239
65240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65241   unsigned int jresult ;
65242   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65243   Dali::Dimension::Type arg2 ;
65244   SwigDirector_ViewImpl *darg = 0;
65245   bool result;
65246
65247   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65248   arg2 = (Dali::Dimension::Type)jarg2;
65249   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65250   if (!darg) {
65251     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65252     return 0;
65253   }
65254   {
65255     try {
65256       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65257     } catch (std::out_of_range& e) {
65258       {
65259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65260       };
65261     } catch (std::exception& e) {
65262       {
65263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65264       };
65265     } catch (Dali::DaliException e) {
65266       {
65267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65268       };
65269     } catch (...) {
65270       {
65271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65272       };
65273     }
65274   }
65275
65276   jresult = result;
65277   return jresult;
65278 }
65279
65280
65281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65282   unsigned int jresult ;
65283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65284   SwigDirector_ViewImpl *darg = 0;
65285   bool result;
65286
65287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65288   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65289   if (!darg) {
65290     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65291     return 0;
65292   }
65293   {
65294     try {
65295       result = (bool)(darg)->RelayoutDependentOnChildren();
65296     } catch (std::out_of_range& e) {
65297       {
65298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65299       };
65300     } catch (std::exception& e) {
65301       {
65302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65303       };
65304     } catch (Dali::DaliException e) {
65305       {
65306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65307       };
65308     } catch (...) {
65309       {
65310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65311       };
65312     }
65313   }
65314
65315   jresult = result;
65316   return jresult;
65317 }
65318
65319
65320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65321   unsigned int jresult ;
65322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65323   SwigDirector_ViewImpl *darg = 0;
65324   bool result;
65325
65326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65327   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65328   if (!darg) {
65329     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65330     return 0;
65331   }
65332   {
65333     try {
65334       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65335     } catch (std::out_of_range& e) {
65336       {
65337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65338       };
65339     } catch (std::exception& e) {
65340       {
65341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65342       };
65343     } catch (Dali::DaliException e) {
65344       {
65345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65346       };
65347     } catch (...) {
65348       {
65349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65350       };
65351     }
65352   }
65353
65354   jresult = result;
65355   return jresult;
65356 }
65357
65358
65359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65360   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65361   Dali::Dimension::Type arg2 ;
65362   SwigDirector_ViewImpl *darg = 0;
65363
65364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65365   arg2 = (Dali::Dimension::Type)jarg2;
65366   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65367   if (!darg) {
65368     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65369     return;
65370   }
65371   {
65372     try {
65373       (darg)->OnCalculateRelayoutSize(arg2);
65374     } catch (std::out_of_range& e) {
65375       {
65376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65377       };
65378     } catch (std::exception& e) {
65379       {
65380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65381       };
65382     } catch (Dali::DaliException e) {
65383       {
65384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65385       };
65386     } catch (...) {
65387       {
65388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65389       };
65390     }
65391   }
65392
65393 }
65394
65395
65396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65397   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65398   Dali::Dimension::Type arg2 ;
65399   SwigDirector_ViewImpl *darg = 0;
65400
65401   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65402   arg2 = (Dali::Dimension::Type)jarg2;
65403   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65404   if (!darg) {
65405     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65406     return;
65407   }
65408   {
65409     try {
65410       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65411     } catch (std::out_of_range& e) {
65412       {
65413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65414       };
65415     } catch (std::exception& e) {
65416       {
65417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65418       };
65419     } catch (Dali::DaliException e) {
65420       {
65421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65422       };
65423     } catch (...) {
65424       {
65425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65426       };
65427     }
65428   }
65429
65430 }
65431
65432
65433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65435   float arg2 ;
65436   Dali::Dimension::Type arg3 ;
65437   SwigDirector_ViewImpl *darg = 0;
65438
65439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65440   arg2 = (float)jarg2;
65441   arg3 = (Dali::Dimension::Type)jarg3;
65442   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65443   if (!darg) {
65444     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65445     return;
65446   }
65447   {
65448     try {
65449       (darg)->OnLayoutNegotiated(arg2,arg3);
65450     } catch (std::out_of_range& e) {
65451       {
65452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65453       };
65454     } catch (std::exception& e) {
65455       {
65456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65457       };
65458     } catch (Dali::DaliException e) {
65459       {
65460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65461       };
65462     } catch (...) {
65463       {
65464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65465       };
65466     }
65467   }
65468
65469 }
65470
65471
65472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65474   float arg2 ;
65475   Dali::Dimension::Type arg3 ;
65476   SwigDirector_ViewImpl *darg = 0;
65477
65478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65479   arg2 = (float)jarg2;
65480   arg3 = (Dali::Dimension::Type)jarg3;
65481   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65482   if (!darg) {
65483     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65484     return;
65485   }
65486   {
65487     try {
65488       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65489     } catch (std::out_of_range& e) {
65490       {
65491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65492       };
65493     } catch (std::exception& e) {
65494       {
65495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65496       };
65497     } catch (Dali::DaliException e) {
65498       {
65499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65500       };
65501     } catch (...) {
65502       {
65503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65504       };
65505     }
65506   }
65507
65508 }
65509
65510
65511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65513
65514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65515   {
65516     try {
65517       (arg1)->OnInitialize();
65518     } catch (std::out_of_range& e) {
65519       {
65520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65521       };
65522     } catch (std::exception& e) {
65523       {
65524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65525       };
65526     } catch (Dali::DaliException e) {
65527       {
65528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65529       };
65530     } catch (...) {
65531       {
65532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65533       };
65534     }
65535   }
65536
65537 }
65538
65539
65540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65541   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65542
65543   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65544   {
65545     try {
65546       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65547     } catch (std::out_of_range& e) {
65548       {
65549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65550       };
65551     } catch (std::exception& e) {
65552       {
65553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65554       };
65555     } catch (Dali::DaliException e) {
65556       {
65557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65558       };
65559     } catch (...) {
65560       {
65561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65562       };
65563     }
65564   }
65565
65566 }
65567
65568
65569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65571   Dali::Actor *arg2 = 0 ;
65572
65573   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65574   arg2 = (Dali::Actor *)jarg2;
65575   if (!arg2) {
65576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65577     return ;
65578   }
65579   {
65580     try {
65581       (arg1)->OnControlChildAdd(*arg2);
65582     } catch (std::out_of_range& e) {
65583       {
65584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65585       };
65586     } catch (std::exception& e) {
65587       {
65588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65589       };
65590     } catch (Dali::DaliException e) {
65591       {
65592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65593       };
65594     } catch (...) {
65595       {
65596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65597       };
65598     }
65599   }
65600
65601 }
65602
65603
65604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65606   Dali::Actor *arg2 = 0 ;
65607
65608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65609   arg2 = (Dali::Actor *)jarg2;
65610   if (!arg2) {
65611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65612     return ;
65613   }
65614   {
65615     try {
65616       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65617     } catch (std::out_of_range& e) {
65618       {
65619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65620       };
65621     } catch (std::exception& e) {
65622       {
65623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65624       };
65625     } catch (Dali::DaliException e) {
65626       {
65627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65628       };
65629     } catch (...) {
65630       {
65631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65632       };
65633     }
65634   }
65635
65636 }
65637
65638
65639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65641   Dali::Actor *arg2 = 0 ;
65642
65643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65644   arg2 = (Dali::Actor *)jarg2;
65645   if (!arg2) {
65646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65647     return ;
65648   }
65649   {
65650     try {
65651       (arg1)->OnControlChildRemove(*arg2);
65652     } catch (std::out_of_range& e) {
65653       {
65654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65655       };
65656     } catch (std::exception& e) {
65657       {
65658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65659       };
65660     } catch (Dali::DaliException e) {
65661       {
65662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65663       };
65664     } catch (...) {
65665       {
65666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65667       };
65668     }
65669   }
65670
65671 }
65672
65673
65674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65676   Dali::Actor *arg2 = 0 ;
65677
65678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65679   arg2 = (Dali::Actor *)jarg2;
65680   if (!arg2) {
65681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65682     return ;
65683   }
65684   {
65685     try {
65686       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65687     } catch (std::out_of_range& e) {
65688       {
65689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65690       };
65691     } catch (std::exception& e) {
65692       {
65693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65694       };
65695     } catch (Dali::DaliException e) {
65696       {
65697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65698       };
65699     } catch (...) {
65700       {
65701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65702       };
65703     }
65704   }
65705
65706 }
65707
65708
65709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65711   Dali::Toolkit::StyleManager arg2 ;
65712   Dali::StyleChange::Type arg3 ;
65713   Dali::Toolkit::StyleManager *argp2 ;
65714
65715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65716   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65717   if (!argp2) {
65718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65719     return ;
65720   }
65721   arg2 = *argp2;
65722   arg3 = (Dali::StyleChange::Type)jarg3;
65723   {
65724     try {
65725       (arg1)->OnStyleChange(arg2,arg3);
65726     } catch (std::out_of_range& e) {
65727       {
65728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65729       };
65730     } catch (std::exception& e) {
65731       {
65732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65733       };
65734     } catch (Dali::DaliException e) {
65735       {
65736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65737       };
65738     } catch (...) {
65739       {
65740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65741       };
65742     }
65743   }
65744
65745 }
65746
65747
65748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65749   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65750   Dali::Toolkit::StyleManager arg2 ;
65751   Dali::StyleChange::Type arg3 ;
65752   Dali::Toolkit::StyleManager *argp2 ;
65753
65754   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65755   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65756   if (!argp2) {
65757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65758     return ;
65759   }
65760   arg2 = *argp2;
65761   arg3 = (Dali::StyleChange::Type)jarg3;
65762   {
65763     try {
65764       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65765     } catch (std::out_of_range& e) {
65766       {
65767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65768       };
65769     } catch (std::exception& e) {
65770       {
65771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65772       };
65773     } catch (Dali::DaliException e) {
65774       {
65775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65776       };
65777     } catch (...) {
65778       {
65779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65780       };
65781     }
65782   }
65783
65784 }
65785
65786
65787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65788   unsigned int jresult ;
65789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65790   bool result;
65791
65792   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65793   {
65794     try {
65795       result = (bool)(arg1)->OnAccessibilityActivated();
65796     } catch (std::out_of_range& e) {
65797       {
65798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65799       };
65800     } catch (std::exception& e) {
65801       {
65802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65803       };
65804     } catch (Dali::DaliException e) {
65805       {
65806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65807       };
65808     } catch (...) {
65809       {
65810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65811       };
65812     }
65813   }
65814
65815   jresult = result;
65816   return jresult;
65817 }
65818
65819
65820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65821   unsigned int jresult ;
65822   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65823   bool result;
65824
65825   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65826   {
65827     try {
65828       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65829     } catch (std::out_of_range& e) {
65830       {
65831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65832       };
65833     } catch (std::exception& e) {
65834       {
65835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65836       };
65837     } catch (Dali::DaliException e) {
65838       {
65839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65840       };
65841     } catch (...) {
65842       {
65843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65844       };
65845     }
65846   }
65847
65848   jresult = result;
65849   return jresult;
65850 }
65851
65852
65853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65854   unsigned int jresult ;
65855   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65856   Dali::PanGesture arg2 ;
65857   Dali::PanGesture *argp2 ;
65858   bool result;
65859
65860   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65861   argp2 = (Dali::PanGesture *)jarg2;
65862   if (!argp2) {
65863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65864     return 0;
65865   }
65866   arg2 = *argp2;
65867   {
65868     try {
65869       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65870     } catch (std::out_of_range& e) {
65871       {
65872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65873       };
65874     } catch (std::exception& e) {
65875       {
65876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65877       };
65878     } catch (Dali::DaliException e) {
65879       {
65880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65881       };
65882     } catch (...) {
65883       {
65884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65885       };
65886     }
65887   }
65888
65889   jresult = result;
65890   return jresult;
65891 }
65892
65893
65894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65895   unsigned int jresult ;
65896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65897   Dali::PanGesture arg2 ;
65898   Dali::PanGesture *argp2 ;
65899   bool result;
65900
65901   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65902   argp2 = (Dali::PanGesture *)jarg2;
65903   if (!argp2) {
65904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65905     return 0;
65906   }
65907   arg2 = *argp2;
65908   {
65909     try {
65910       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65911     } catch (std::out_of_range& e) {
65912       {
65913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65914       };
65915     } catch (std::exception& e) {
65916       {
65917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65918       };
65919     } catch (Dali::DaliException e) {
65920       {
65921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65922       };
65923     } catch (...) {
65924       {
65925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65926       };
65927     }
65928   }
65929
65930   jresult = result;
65931   return jresult;
65932 }
65933
65934
65935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65936   unsigned int jresult ;
65937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65938   Dali::TouchEvent *arg2 = 0 ;
65939   bool result;
65940
65941   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65942   arg2 = (Dali::TouchEvent *)jarg2;
65943   if (!arg2) {
65944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65945     return 0;
65946   }
65947   {
65948     try {
65949       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65950     } catch (std::out_of_range& e) {
65951       {
65952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65953       };
65954     } catch (std::exception& e) {
65955       {
65956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65957       };
65958     } catch (Dali::DaliException e) {
65959       {
65960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65961       };
65962     } catch (...) {
65963       {
65964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65965       };
65966     }
65967   }
65968
65969   jresult = result;
65970   return jresult;
65971 }
65972
65973
65974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65975   unsigned int jresult ;
65976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65977   Dali::TouchEvent *arg2 = 0 ;
65978   bool result;
65979
65980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65981   arg2 = (Dali::TouchEvent *)jarg2;
65982   if (!arg2) {
65983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65984     return 0;
65985   }
65986   {
65987     try {
65988       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65989     } catch (std::out_of_range& e) {
65990       {
65991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65992       };
65993     } catch (std::exception& e) {
65994       {
65995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65996       };
65997     } catch (Dali::DaliException e) {
65998       {
65999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66000       };
66001     } catch (...) {
66002       {
66003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66004       };
66005     }
66006   }
66007
66008   jresult = result;
66009   return jresult;
66010 }
66011
66012
66013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66014   unsigned int jresult ;
66015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66016   bool arg2 ;
66017   bool result;
66018
66019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66020   arg2 = jarg2 ? true : false;
66021   {
66022     try {
66023       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66024     } catch (std::out_of_range& e) {
66025       {
66026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66027       };
66028     } catch (std::exception& e) {
66029       {
66030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66031       };
66032     } catch (Dali::DaliException e) {
66033       {
66034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66035       };
66036     } catch (...) {
66037       {
66038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66039       };
66040     }
66041   }
66042
66043   jresult = result;
66044   return jresult;
66045 }
66046
66047
66048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66049   unsigned int jresult ;
66050   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66051   bool arg2 ;
66052   bool result;
66053
66054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66055   arg2 = jarg2 ? true : false;
66056   {
66057     try {
66058       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66059     } catch (std::out_of_range& e) {
66060       {
66061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66062       };
66063     } catch (std::exception& e) {
66064       {
66065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66066       };
66067     } catch (Dali::DaliException e) {
66068       {
66069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66070       };
66071     } catch (...) {
66072       {
66073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66074       };
66075     }
66076   }
66077
66078   jresult = result;
66079   return jresult;
66080 }
66081
66082
66083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66084   unsigned int jresult ;
66085   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66086   bool result;
66087
66088   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66089   {
66090     try {
66091       result = (bool)(arg1)->OnAccessibilityZoom();
66092     } catch (std::out_of_range& e) {
66093       {
66094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66095       };
66096     } catch (std::exception& e) {
66097       {
66098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66099       };
66100     } catch (Dali::DaliException e) {
66101       {
66102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66103       };
66104     } catch (...) {
66105       {
66106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66107       };
66108     }
66109   }
66110
66111   jresult = result;
66112   return jresult;
66113 }
66114
66115
66116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66117   unsigned int jresult ;
66118   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66119   bool result;
66120
66121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66122   {
66123     try {
66124       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66125     } catch (std::out_of_range& e) {
66126       {
66127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66128       };
66129     } catch (std::exception& e) {
66130       {
66131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66132       };
66133     } catch (Dali::DaliException e) {
66134       {
66135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66136       };
66137     } catch (...) {
66138       {
66139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66140       };
66141     }
66142   }
66143
66144   jresult = result;
66145   return jresult;
66146 }
66147
66148
66149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66150   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66151
66152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66153   {
66154     try {
66155       (arg1)->OnKeyInputFocusGained();
66156     } catch (std::out_of_range& e) {
66157       {
66158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66159       };
66160     } catch (std::exception& e) {
66161       {
66162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66163       };
66164     } catch (Dali::DaliException e) {
66165       {
66166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66167       };
66168     } catch (...) {
66169       {
66170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66171       };
66172     }
66173   }
66174
66175 }
66176
66177
66178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66179   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66180
66181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66182   {
66183     try {
66184       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66185     } catch (std::out_of_range& e) {
66186       {
66187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66188       };
66189     } catch (std::exception& e) {
66190       {
66191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66192       };
66193     } catch (Dali::DaliException e) {
66194       {
66195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66196       };
66197     } catch (...) {
66198       {
66199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66200       };
66201     }
66202   }
66203
66204 }
66205
66206
66207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66208   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66209
66210   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66211   {
66212     try {
66213       (arg1)->OnKeyInputFocusLost();
66214     } catch (std::out_of_range& e) {
66215       {
66216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66217       };
66218     } catch (std::exception& e) {
66219       {
66220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66221       };
66222     } catch (Dali::DaliException e) {
66223       {
66224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66225       };
66226     } catch (...) {
66227       {
66228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66229       };
66230     }
66231   }
66232
66233 }
66234
66235
66236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66237   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66238
66239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66240   {
66241     try {
66242       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66243     } catch (std::out_of_range& e) {
66244       {
66245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66246       };
66247     } catch (std::exception& e) {
66248       {
66249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66250       };
66251     } catch (Dali::DaliException e) {
66252       {
66253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66254       };
66255     } catch (...) {
66256       {
66257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66258       };
66259     }
66260   }
66261
66262 }
66263
66264
66265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66266   void * jresult ;
66267   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66268   Dali::Actor arg2 ;
66269   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66270   bool arg4 ;
66271   Dali::Actor *argp2 ;
66272   Dali::Actor result;
66273
66274   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66275   argp2 = (Dali::Actor *)jarg2;
66276   if (!argp2) {
66277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66278     return 0;
66279   }
66280   arg2 = *argp2;
66281   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66282   arg4 = jarg4 ? true : false;
66283   {
66284     try {
66285       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66286     } catch (std::out_of_range& e) {
66287       {
66288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66289       };
66290     } catch (std::exception& e) {
66291       {
66292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66293       };
66294     } catch (Dali::DaliException e) {
66295       {
66296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66297       };
66298     } catch (...) {
66299       {
66300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66301       };
66302     }
66303   }
66304
66305   jresult = new Dali::Actor((const Dali::Actor &)result);
66306   return jresult;
66307 }
66308
66309
66310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66311   void * jresult ;
66312   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66313   Dali::Actor arg2 ;
66314   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66315   bool arg4 ;
66316   Dali::Actor *argp2 ;
66317   Dali::Actor result;
66318
66319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66320   argp2 = (Dali::Actor *)jarg2;
66321   if (!argp2) {
66322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66323     return 0;
66324   }
66325   arg2 = *argp2;
66326   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66327   arg4 = jarg4 ? true : false;
66328   {
66329     try {
66330       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66331     } catch (std::out_of_range& e) {
66332       {
66333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66334       };
66335     } catch (std::exception& e) {
66336       {
66337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66338       };
66339     } catch (Dali::DaliException e) {
66340       {
66341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66342       };
66343     } catch (...) {
66344       {
66345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66346       };
66347     }
66348   }
66349
66350   jresult = new Dali::Actor((const Dali::Actor &)result);
66351   return jresult;
66352 }
66353
66354
66355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66357   Dali::Actor arg2 ;
66358   Dali::Actor *argp2 ;
66359
66360   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66361   argp2 = (Dali::Actor *)jarg2;
66362   if (!argp2) {
66363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66364     return ;
66365   }
66366   arg2 = *argp2;
66367   {
66368     try {
66369       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66370     } catch (std::out_of_range& e) {
66371       {
66372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66373       };
66374     } catch (std::exception& e) {
66375       {
66376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66377       };
66378     } catch (Dali::DaliException e) {
66379       {
66380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66381       };
66382     } catch (...) {
66383       {
66384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66385       };
66386     }
66387   }
66388
66389 }
66390
66391
66392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66393   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66394   Dali::Actor arg2 ;
66395   Dali::Actor *argp2 ;
66396
66397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66398   argp2 = (Dali::Actor *)jarg2;
66399   if (!argp2) {
66400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66401     return ;
66402   }
66403   arg2 = *argp2;
66404   {
66405     try {
66406       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66407     } catch (std::out_of_range& e) {
66408       {
66409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66410       };
66411     } catch (std::exception& e) {
66412       {
66413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66414       };
66415     } catch (Dali::DaliException e) {
66416       {
66417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66418       };
66419     } catch (...) {
66420       {
66421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66422       };
66423     }
66424   }
66425
66426 }
66427
66428
66429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66430   unsigned int jresult ;
66431   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66432   bool result;
66433
66434   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66435   {
66436     try {
66437       result = (bool)(arg1)->OnKeyboardEnter();
66438     } catch (std::out_of_range& e) {
66439       {
66440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66441       };
66442     } catch (std::exception& e) {
66443       {
66444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66445       };
66446     } catch (Dali::DaliException e) {
66447       {
66448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66449       };
66450     } catch (...) {
66451       {
66452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66453       };
66454     }
66455   }
66456
66457   jresult = result;
66458   return jresult;
66459 }
66460
66461
66462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66463   unsigned int jresult ;
66464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66465   bool result;
66466
66467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66468   {
66469     try {
66470       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66471     } catch (std::out_of_range& e) {
66472       {
66473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66474       };
66475     } catch (std::exception& e) {
66476       {
66477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66478       };
66479     } catch (Dali::DaliException e) {
66480       {
66481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66482       };
66483     } catch (...) {
66484       {
66485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66486       };
66487     }
66488   }
66489
66490   jresult = result;
66491   return jresult;
66492 }
66493
66494
66495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66496   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66497   Dali::PinchGesture *arg2 = 0 ;
66498
66499   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66500   arg2 = (Dali::PinchGesture *)jarg2;
66501   if (!arg2) {
66502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66503     return ;
66504   }
66505   {
66506     try {
66507       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66508     } catch (std::out_of_range& e) {
66509       {
66510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66511       };
66512     } catch (std::exception& e) {
66513       {
66514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66515       };
66516     } catch (Dali::DaliException e) {
66517       {
66518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66519       };
66520     } catch (...) {
66521       {
66522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66523       };
66524     }
66525   }
66526
66527 }
66528
66529
66530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66531   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66532   Dali::PinchGesture *arg2 = 0 ;
66533
66534   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66535   arg2 = (Dali::PinchGesture *)jarg2;
66536   if (!arg2) {
66537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66538     return ;
66539   }
66540   {
66541     try {
66542       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66543     } catch (std::out_of_range& e) {
66544       {
66545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66546       };
66547     } catch (std::exception& e) {
66548       {
66549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66550       };
66551     } catch (Dali::DaliException e) {
66552       {
66553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66554       };
66555     } catch (...) {
66556       {
66557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66558       };
66559     }
66560   }
66561
66562 }
66563
66564
66565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66566   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66567   Dali::PanGesture *arg2 = 0 ;
66568
66569   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66570   arg2 = (Dali::PanGesture *)jarg2;
66571   if (!arg2) {
66572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66573     return ;
66574   }
66575   {
66576     try {
66577       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66578     } catch (std::out_of_range& e) {
66579       {
66580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66581       };
66582     } catch (std::exception& e) {
66583       {
66584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66585       };
66586     } catch (Dali::DaliException e) {
66587       {
66588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66589       };
66590     } catch (...) {
66591       {
66592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66593       };
66594     }
66595   }
66596
66597 }
66598
66599
66600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66601   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66602   Dali::PanGesture *arg2 = 0 ;
66603
66604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66605   arg2 = (Dali::PanGesture *)jarg2;
66606   if (!arg2) {
66607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66608     return ;
66609   }
66610   {
66611     try {
66612       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66613     } catch (std::out_of_range& e) {
66614       {
66615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66616       };
66617     } catch (std::exception& e) {
66618       {
66619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66620       };
66621     } catch (Dali::DaliException e) {
66622       {
66623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66624       };
66625     } catch (...) {
66626       {
66627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66628       };
66629     }
66630   }
66631
66632 }
66633
66634
66635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66637   Dali::TapGesture *arg2 = 0 ;
66638
66639   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66640   arg2 = (Dali::TapGesture *)jarg2;
66641   if (!arg2) {
66642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66643     return ;
66644   }
66645   {
66646     try {
66647       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66648     } catch (std::out_of_range& e) {
66649       {
66650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66651       };
66652     } catch (std::exception& e) {
66653       {
66654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66655       };
66656     } catch (Dali::DaliException e) {
66657       {
66658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66659       };
66660     } catch (...) {
66661       {
66662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66663       };
66664     }
66665   }
66666
66667 }
66668
66669
66670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66671   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66672   Dali::TapGesture *arg2 = 0 ;
66673
66674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66675   arg2 = (Dali::TapGesture *)jarg2;
66676   if (!arg2) {
66677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66678     return ;
66679   }
66680   {
66681     try {
66682       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66683     } catch (std::out_of_range& e) {
66684       {
66685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66686       };
66687     } catch (std::exception& e) {
66688       {
66689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66690       };
66691     } catch (Dali::DaliException e) {
66692       {
66693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66694       };
66695     } catch (...) {
66696       {
66697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66698       };
66699     }
66700   }
66701
66702 }
66703
66704
66705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66706   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66707   Dali::LongPressGesture *arg2 = 0 ;
66708
66709   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66710   arg2 = (Dali::LongPressGesture *)jarg2;
66711   if (!arg2) {
66712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66713     return ;
66714   }
66715   {
66716     try {
66717       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66718     } catch (std::out_of_range& e) {
66719       {
66720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66721       };
66722     } catch (std::exception& e) {
66723       {
66724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66725       };
66726     } catch (Dali::DaliException e) {
66727       {
66728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66729       };
66730     } catch (...) {
66731       {
66732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66733       };
66734     }
66735   }
66736
66737 }
66738
66739
66740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66741   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66742   Dali::LongPressGesture *arg2 = 0 ;
66743
66744   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66745   arg2 = (Dali::LongPressGesture *)jarg2;
66746   if (!arg2) {
66747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66748     return ;
66749   }
66750   {
66751     try {
66752       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66753     } catch (std::out_of_range& e) {
66754       {
66755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66756       };
66757     } catch (std::exception& e) {
66758       {
66759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66760       };
66761     } catch (Dali::DaliException e) {
66762       {
66763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66764       };
66765     } catch (...) {
66766       {
66767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66768       };
66769     }
66770   }
66771
66772 }
66773
66774
66775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66777   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66778   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66779
66780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66781   arg2 = (Dali::SlotObserver *)jarg2;
66782   arg3 = (Dali::CallbackBase *)jarg3;
66783   {
66784     try {
66785       (arg1)->SignalConnected(arg2,arg3);
66786     } catch (std::out_of_range& e) {
66787       {
66788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66789       };
66790     } catch (std::exception& e) {
66791       {
66792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66793       };
66794     } catch (Dali::DaliException e) {
66795       {
66796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66797       };
66798     } catch (...) {
66799       {
66800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66801       };
66802     }
66803   }
66804
66805 }
66806
66807
66808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66809   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66810   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66811   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66812
66813   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66814   arg2 = (Dali::SlotObserver *)jarg2;
66815   arg3 = (Dali::CallbackBase *)jarg3;
66816   {
66817     try {
66818       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66819     } catch (std::out_of_range& e) {
66820       {
66821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66822       };
66823     } catch (std::exception& e) {
66824       {
66825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66826       };
66827     } catch (Dali::DaliException e) {
66828       {
66829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66830       };
66831     } catch (...) {
66832       {
66833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66834       };
66835     }
66836   }
66837
66838 }
66839
66840
66841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66842   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66843   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66844   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66845
66846   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66847   arg2 = (Dali::SlotObserver *)jarg2;
66848   arg3 = (Dali::CallbackBase *)jarg3;
66849   {
66850     try {
66851       (arg1)->SignalDisconnected(arg2,arg3);
66852     } catch (std::out_of_range& e) {
66853       {
66854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66855       };
66856     } catch (std::exception& e) {
66857       {
66858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66859       };
66860     } catch (Dali::DaliException e) {
66861       {
66862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66863       };
66864     } catch (...) {
66865       {
66866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66867       };
66868     }
66869   }
66870
66871 }
66872
66873
66874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66875   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66876   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66877   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66878
66879   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66880   arg2 = (Dali::SlotObserver *)jarg2;
66881   arg3 = (Dali::CallbackBase *)jarg3;
66882   {
66883     try {
66884       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66885     } catch (std::out_of_range& e) {
66886       {
66887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66888       };
66889     } catch (std::exception& e) {
66890       {
66891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66892       };
66893     } catch (Dali::DaliException e) {
66894       {
66895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66896       };
66897     } catch (...) {
66898       {
66899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66900       };
66901     }
66902   }
66903
66904 }
66905
66906
66907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_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) {
66908   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66909   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66910   if (director) {
66911     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);
66912   }
66913 }
66914
66915
66916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66917   void * jresult ;
66918   Dali::Toolkit::Control *arg1 = 0 ;
66919   Dali::Toolkit::Internal::Control *result = 0 ;
66920
66921   arg1 = (Dali::Toolkit::Control *)jarg1;
66922   if (!arg1) {
66923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66924     return 0;
66925   }
66926   {
66927     try {
66928       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66929     } catch (std::out_of_range& e) {
66930       {
66931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66932       };
66933     } catch (std::exception& e) {
66934       {
66935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66936       };
66937     } catch (Dali::DaliException e) {
66938       {
66939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66940       };
66941     } catch (...) {
66942       {
66943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66944       };
66945     }
66946   }
66947
66948   jresult = (void *)result;
66949   return jresult;
66950 }
66951
66952
66953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66954   int jresult ;
66955   int result;
66956
66957   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66958   jresult = (int)result;
66959   return jresult;
66960 }
66961
66962
66963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
66964   int jresult ;
66965   int result;
66966
66967   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
66968   jresult = (int)result;
66969   return jresult;
66970 }
66971
66972
66973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
66974   int jresult ;
66975   int result;
66976
66977   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
66978   jresult = (int)result;
66979   return jresult;
66980 }
66981
66982
66983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
66984   int jresult ;
66985   int result;
66986
66987   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
66988   jresult = (int)result;
66989   return jresult;
66990 }
66991
66992
66993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
66994   int jresult ;
66995   int result;
66996
66997   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
66998   jresult = (int)result;
66999   return jresult;
67000 }
67001
67002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67003   int jresult ;
67004   int result;
67005
67006   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67007   jresult = (int)result;
67008   return jresult;
67009 }
67010
67011
67012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67013   int jresult ;
67014   int result;
67015
67016   result = (int)Dali::Toolkit::Control::Property::PADDING;
67017   jresult = (int)result;
67018   return jresult;
67019 }
67020
67021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67022   void * jresult ;
67023   Dali::Toolkit::Control::Property *result = 0 ;
67024
67025   {
67026     try {
67027       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67028     } catch (std::out_of_range& e) {
67029       {
67030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67031       };
67032     } catch (std::exception& e) {
67033       {
67034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67035       };
67036     } catch (Dali::DaliException e) {
67037       {
67038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67039       };
67040     } catch (...) {
67041       {
67042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67043       };
67044     }
67045   }
67046
67047   jresult = (void *)result;
67048   return jresult;
67049 }
67050
67051
67052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67053   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67054
67055   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67056   {
67057     try {
67058       delete arg1;
67059     } catch (std::out_of_range& e) {
67060       {
67061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67062       };
67063     } catch (std::exception& e) {
67064       {
67065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67066       };
67067     } catch (Dali::DaliException e) {
67068       {
67069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67070       };
67071     } catch (...) {
67072       {
67073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67074       };
67075     }
67076   }
67077
67078 }
67079
67080
67081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67082   void * jresult ;
67083   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67084
67085   {
67086     try {
67087       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67088     } catch (std::out_of_range& e) {
67089       {
67090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67091       };
67092     } catch (std::exception& e) {
67093       {
67094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67095       };
67096     } catch (Dali::DaliException e) {
67097       {
67098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67099       };
67100     } catch (...) {
67101       {
67102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67103       };
67104     }
67105   }
67106
67107   jresult = (void *)result;
67108   return jresult;
67109 }
67110
67111
67112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67113   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67114
67115   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67116   {
67117     try {
67118       delete arg1;
67119     } catch (std::out_of_range& e) {
67120       {
67121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67122       };
67123     } catch (std::exception& e) {
67124       {
67125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67126       };
67127     } catch (Dali::DaliException e) {
67128       {
67129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67130       };
67131     } catch (...) {
67132       {
67133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67134       };
67135     }
67136   }
67137
67138 }
67139
67140
67141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67142   void * jresult ;
67143   Dali::Toolkit::Control result;
67144
67145   {
67146     try {
67147       result = Dali::Toolkit::Control::New();
67148     } catch (std::out_of_range& e) {
67149       {
67150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67151       };
67152     } catch (std::exception& e) {
67153       {
67154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67155       };
67156     } catch (Dali::DaliException e) {
67157       {
67158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67159       };
67160     } catch (...) {
67161       {
67162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67163       };
67164     }
67165   }
67166
67167   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67168   return jresult;
67169 }
67170
67171
67172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67173   void * jresult ;
67174   Dali::Toolkit::Control *result = 0 ;
67175
67176   {
67177     try {
67178       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67179     } catch (std::out_of_range& e) {
67180       {
67181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67182       };
67183     } catch (std::exception& e) {
67184       {
67185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67186       };
67187     } catch (Dali::DaliException e) {
67188       {
67189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67190       };
67191     } catch (...) {
67192       {
67193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67194       };
67195     }
67196   }
67197
67198   jresult = (void *)result;
67199   return jresult;
67200 }
67201
67202
67203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67204   void * jresult ;
67205   Dali::Toolkit::Control *arg1 = 0 ;
67206   Dali::Toolkit::Control *result = 0 ;
67207
67208   arg1 = (Dali::Toolkit::Control *)jarg1;
67209   if (!arg1) {
67210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67211     return 0;
67212   }
67213   {
67214     try {
67215       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67216     } catch (std::out_of_range& e) {
67217       {
67218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67219       };
67220     } catch (std::exception& e) {
67221       {
67222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67223       };
67224     } catch (Dali::DaliException e) {
67225       {
67226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67227       };
67228     } catch (...) {
67229       {
67230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67231       };
67232     }
67233   }
67234
67235   jresult = (void *)result;
67236   return jresult;
67237 }
67238
67239
67240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67241   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67242
67243   arg1 = (Dali::Toolkit::Control *)jarg1;
67244   {
67245     try {
67246       delete arg1;
67247     } catch (std::out_of_range& e) {
67248       {
67249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67250       };
67251     } catch (std::exception& e) {
67252       {
67253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67254       };
67255     } catch (Dali::DaliException e) {
67256       {
67257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67258       };
67259     } catch (...) {
67260       {
67261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67262       };
67263     }
67264   }
67265
67266 }
67267
67268
67269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67270   void * jresult ;
67271   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67272   Dali::Toolkit::Control *arg2 = 0 ;
67273   Dali::Toolkit::Control *result = 0 ;
67274
67275   arg1 = (Dali::Toolkit::Control *)jarg1;
67276   arg2 = (Dali::Toolkit::Control *)jarg2;
67277   if (!arg2) {
67278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67279     return 0;
67280   }
67281   {
67282     try {
67283       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67284     } catch (std::out_of_range& e) {
67285       {
67286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67287       };
67288     } catch (std::exception& e) {
67289       {
67290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67291       };
67292     } catch (Dali::DaliException e) {
67293       {
67294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67295       };
67296     } catch (...) {
67297       {
67298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67299       };
67300     }
67301   }
67302
67303   jresult = (void *)result;
67304   return jresult;
67305 }
67306
67307
67308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67309   void * jresult ;
67310   Dali::BaseHandle arg1 ;
67311   Dali::BaseHandle *argp1 ;
67312   Dali::Toolkit::Control result;
67313
67314   argp1 = (Dali::BaseHandle *)jarg1;
67315   if (!argp1) {
67316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67317     return 0;
67318   }
67319   arg1 = *argp1;
67320   {
67321     try {
67322       result = Dali::Toolkit::Control::DownCast(arg1);
67323     } catch (std::out_of_range& e) {
67324       {
67325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67326       };
67327     } catch (std::exception& e) {
67328       {
67329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67330       };
67331     } catch (Dali::DaliException e) {
67332       {
67333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67334       };
67335     } catch (...) {
67336       {
67337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67338       };
67339     }
67340   }
67341
67342   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67343   return jresult;
67344 }
67345
67346
67347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67348   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67349
67350   arg1 = (Dali::Toolkit::Control *)jarg1;
67351   {
67352     try {
67353       (arg1)->SetKeyInputFocus();
67354     } catch (std::out_of_range& e) {
67355       {
67356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67357       };
67358     } catch (std::exception& e) {
67359       {
67360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67361       };
67362     } catch (Dali::DaliException e) {
67363       {
67364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67365       };
67366     } catch (...) {
67367       {
67368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67369       };
67370     }
67371   }
67372
67373 }
67374
67375
67376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67377   unsigned int jresult ;
67378   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67379   bool result;
67380
67381   arg1 = (Dali::Toolkit::Control *)jarg1;
67382   {
67383     try {
67384       result = (bool)(arg1)->HasKeyInputFocus();
67385     } catch (std::out_of_range& e) {
67386       {
67387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67388       };
67389     } catch (std::exception& e) {
67390       {
67391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67392       };
67393     } catch (Dali::DaliException e) {
67394       {
67395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67396       };
67397     } catch (...) {
67398       {
67399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67400       };
67401     }
67402   }
67403
67404   jresult = result;
67405   return jresult;
67406 }
67407
67408
67409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67410   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67411
67412   arg1 = (Dali::Toolkit::Control *)jarg1;
67413   {
67414     try {
67415       (arg1)->ClearKeyInputFocus();
67416     } catch (std::out_of_range& e) {
67417       {
67418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67419       };
67420     } catch (std::exception& e) {
67421       {
67422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67423       };
67424     } catch (Dali::DaliException e) {
67425       {
67426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67427       };
67428     } catch (...) {
67429       {
67430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67431       };
67432     }
67433   }
67434
67435 }
67436
67437
67438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67439   void * jresult ;
67440   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67441   Dali::PinchGestureDetector result;
67442
67443   arg1 = (Dali::Toolkit::Control *)jarg1;
67444   {
67445     try {
67446       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67447     } catch (std::out_of_range& e) {
67448       {
67449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67450       };
67451     } catch (std::exception& e) {
67452       {
67453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67454       };
67455     } catch (Dali::DaliException e) {
67456       {
67457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67458       };
67459     } catch (...) {
67460       {
67461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67462       };
67463     }
67464   }
67465
67466   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67467   return jresult;
67468 }
67469
67470
67471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67472   void * jresult ;
67473   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67474   Dali::PanGestureDetector result;
67475
67476   arg1 = (Dali::Toolkit::Control *)jarg1;
67477   {
67478     try {
67479       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67480     } catch (std::out_of_range& e) {
67481       {
67482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67483       };
67484     } catch (std::exception& e) {
67485       {
67486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67487       };
67488     } catch (Dali::DaliException e) {
67489       {
67490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67491       };
67492     } catch (...) {
67493       {
67494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67495       };
67496     }
67497   }
67498
67499   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67500   return jresult;
67501 }
67502
67503
67504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67505   void * jresult ;
67506   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67507   Dali::TapGestureDetector result;
67508
67509   arg1 = (Dali::Toolkit::Control *)jarg1;
67510   {
67511     try {
67512       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67513     } catch (std::out_of_range& e) {
67514       {
67515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67516       };
67517     } catch (std::exception& e) {
67518       {
67519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67520       };
67521     } catch (Dali::DaliException e) {
67522       {
67523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67524       };
67525     } catch (...) {
67526       {
67527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67528       };
67529     }
67530   }
67531
67532   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67533   return jresult;
67534 }
67535
67536
67537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67538   void * jresult ;
67539   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67540   Dali::LongPressGestureDetector result;
67541
67542   arg1 = (Dali::Toolkit::Control *)jarg1;
67543   {
67544     try {
67545       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67546     } catch (std::out_of_range& e) {
67547       {
67548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67549       };
67550     } catch (std::exception& e) {
67551       {
67552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67553       };
67554     } catch (Dali::DaliException e) {
67555       {
67556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67557       };
67558     } catch (...) {
67559       {
67560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67561       };
67562     }
67563   }
67564
67565   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67566   return jresult;
67567 }
67568
67569
67570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67571   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67572   std::string *arg2 = 0 ;
67573
67574   arg1 = (Dali::Toolkit::Control *)jarg1;
67575   if (!jarg2) {
67576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67577     return ;
67578   }
67579   std::string arg2_str(jarg2);
67580   arg2 = &arg2_str;
67581   {
67582     try {
67583       (arg1)->SetStyleName((std::string const &)*arg2);
67584     } catch (std::out_of_range& e) {
67585       {
67586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67587       };
67588     } catch (std::exception& e) {
67589       {
67590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67591       };
67592     } catch (Dali::DaliException e) {
67593       {
67594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67595       };
67596     } catch (...) {
67597       {
67598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67599       };
67600     }
67601   }
67602
67603
67604   //argout typemap for const std::string&
67605
67606 }
67607
67608
67609 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67610   char * jresult ;
67611   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67612   std::string *result = 0 ;
67613
67614   arg1 = (Dali::Toolkit::Control *)jarg1;
67615   {
67616     try {
67617       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67618     } catch (std::out_of_range& e) {
67619       {
67620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67621       };
67622     } catch (std::exception& e) {
67623       {
67624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67625       };
67626     } catch (Dali::DaliException e) {
67627       {
67628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67629       };
67630     } catch (...) {
67631       {
67632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67633       };
67634     }
67635   }
67636
67637   jresult = SWIG_csharp_string_callback(result->c_str());
67638   return jresult;
67639 }
67640
67641
67642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67643   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67644   Dali::Vector4 *arg2 = 0 ;
67645
67646   arg1 = (Dali::Toolkit::Control *)jarg1;
67647   arg2 = (Dali::Vector4 *)jarg2;
67648   if (!arg2) {
67649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67650     return ;
67651   }
67652   {
67653     try {
67654       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67655     } catch (std::out_of_range& e) {
67656       {
67657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67658       };
67659     } catch (std::exception& e) {
67660       {
67661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67662       };
67663     } catch (Dali::DaliException e) {
67664       {
67665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67666       };
67667     } catch (...) {
67668       {
67669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67670       };
67671     }
67672   }
67673
67674 }
67675
67676
67677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67678   void * jresult ;
67679   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67680   Dali::Vector4 result;
67681
67682   arg1 = (Dali::Toolkit::Control *)jarg1;
67683   {
67684     try {
67685       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67686     } catch (std::out_of_range& e) {
67687       {
67688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67689       };
67690     } catch (std::exception& e) {
67691       {
67692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67693       };
67694     } catch (Dali::DaliException e) {
67695       {
67696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67697       };
67698     } catch (...) {
67699       {
67700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67701       };
67702     }
67703   }
67704
67705   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67706   return jresult;
67707 }
67708
67709
67710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67711   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67712   Dali::Image arg2 ;
67713   Dali::Image *argp2 ;
67714
67715   arg1 = (Dali::Toolkit::Control *)jarg1;
67716   argp2 = (Dali::Image *)jarg2;
67717   if (!argp2) {
67718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67719     return ;
67720   }
67721   arg2 = *argp2;
67722   {
67723     try {
67724       (arg1)->SetBackgroundImage(arg2);
67725     } catch (std::out_of_range& e) {
67726       {
67727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67728       };
67729     } catch (std::exception& e) {
67730       {
67731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67732       };
67733     } catch (Dali::DaliException e) {
67734       {
67735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67736       };
67737     } catch (...) {
67738       {
67739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67740       };
67741     }
67742   }
67743
67744 }
67745
67746
67747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67748   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67749
67750   arg1 = (Dali::Toolkit::Control *)jarg1;
67751   {
67752     try {
67753       (arg1)->ClearBackground();
67754     } catch (std::out_of_range& e) {
67755       {
67756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67757       };
67758     } catch (std::exception& e) {
67759       {
67760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67761       };
67762     } catch (Dali::DaliException e) {
67763       {
67764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67765       };
67766     } catch (...) {
67767       {
67768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67769       };
67770     }
67771   }
67772
67773 }
67774
67775
67776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67777   void * jresult ;
67778   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67779   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67780
67781   arg1 = (Dali::Toolkit::Control *)jarg1;
67782   {
67783     try {
67784       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67785     } catch (std::out_of_range& e) {
67786       {
67787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67788       };
67789     } catch (std::exception& e) {
67790       {
67791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67792       };
67793     } catch (Dali::DaliException e) {
67794       {
67795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67796       };
67797     } catch (...) {
67798       {
67799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67800       };
67801     }
67802   }
67803
67804   jresult = (void *)result;
67805   return jresult;
67806 }
67807
67808
67809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67810   void * jresult ;
67811   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67812   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67813
67814   arg1 = (Dali::Toolkit::Control *)jarg1;
67815   {
67816     try {
67817       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67818     } catch (std::out_of_range& e) {
67819       {
67820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67821       };
67822     } catch (std::exception& e) {
67823       {
67824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67825       };
67826     } catch (Dali::DaliException e) {
67827       {
67828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67829       };
67830     } catch (...) {
67831       {
67832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67833       };
67834     }
67835   }
67836
67837   jresult = (void *)result;
67838   return jresult;
67839 }
67840
67841
67842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67843   void * jresult ;
67844   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67845   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67846
67847   arg1 = (Dali::Toolkit::Control *)jarg1;
67848   {
67849     try {
67850       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
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
67875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67876   void * jresult ;
67877   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67878   Dali::Toolkit::Control *result = 0 ;
67879
67880   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67881   if (!arg1) {
67882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67883     return 0;
67884   }
67885   {
67886     try {
67887       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67888     } catch (std::out_of_range& e) {
67889       {
67890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67891       };
67892     } catch (std::exception& e) {
67893       {
67894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67895       };
67896     } catch (Dali::DaliException e) {
67897       {
67898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67899       };
67900     } catch (...) {
67901       {
67902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67903       };
67904     }
67905   }
67906
67907   jresult = (void *)result;
67908   return jresult;
67909 }
67910
67911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67912 {
67913   int jresult;
67914   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67915   arg1 = (Dali::Toolkit::Control *)jarg1;
67916
67917   if (!arg1) {
67918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67919     return 0;
67920   }
67921
67922   Dali::Property::Index arg2 = 0 ;
67923   arg2 = (Dali::Property::Index)jarg2;
67924
67925   Toolkit::Visual::ResourceStatus result;
67926   {
67927     try {
67928       result = arg1->GetVisualResourceStatus(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 (...) {
67938       {
67939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67940       };
67941     }
67942   }
67943   jresult = (int)(result);
67944   return jresult;
67945 }
67946
67947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67948 {
67949   void * jresult;
67950   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67951   arg1 = (Dali::Toolkit::Control *)jarg1;
67952
67953   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67954
67955   Dali::Toolkit::TransitionData *arg2 = 0 ;
67956   Dali::Animation result;
67957
67958   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67959   if (!arg2) {
67960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67961     return 0;
67962   }
67963   {
67964     try {
67965       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67966     } catch (std::out_of_range& e) {
67967       {
67968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67969       };
67970     } catch (std::exception& e) {
67971       {
67972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67973       };
67974     } catch (Dali::DaliException e) {
67975       {
67976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67977       };
67978     } catch (...) {
67979       {
67980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67981       };
67982     }
67983   }
67984
67985   jresult = new Dali::Animation((const Dali::Animation &)result);
67986   return jresult;
67987 }
67988
67989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67990 {
67991   Dali::Toolkit::Control arg1;
67992   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67993
67994   if (!argp1) {
67995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67996   }
67997   arg1 = *argp1;
67998
67999   Dali::Property::Index arg2 = 0 ;
68000   arg2 = (Dali::Property::Index)jarg2;
68001
68002   Dali::Property::Index arg3 = 0 ;
68003   arg3 = (Dali::Property::Index)jarg3;
68004
68005   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
68006
68007   {
68008     try {
68009       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
68010     } catch (std::out_of_range& e) {
68011       {
68012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68013       };
68014     } catch (std::exception& e) {
68015       {
68016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68017       };
68018     } catch (...) {
68019       {
68020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68021       };
68022     }
68023   }
68024
68025
68026 }
68027
68028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68029   void * jresult ;
68030   Dali::Toolkit::Control *arg1 = 0 ;
68031   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68032
68033   arg1 = (Dali::Toolkit::Control *)jarg1;
68034   if (!arg1) {
68035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68036     return 0;
68037   }
68038   {
68039     try {
68040       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
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 = (void *)result;
68061   return jresult;
68062 }
68063
68064
68065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68066   unsigned int jresult ;
68067   Dali::Toolkit::Control *arg1 = 0 ;
68068   bool result;
68069
68070   arg1 = (Dali::Toolkit::Control *)jarg1;
68071   if (!arg1) {
68072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68073     return 0;
68074   }
68075   {
68076     try {
68077       result = (bool)arg1->IsResourceReady();
68078     } catch (std::out_of_range& e) {
68079       {
68080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68081       };
68082     } catch (std::exception& e) {
68083       {
68084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68085       };
68086     } catch (Dali::DaliException e) {
68087       {
68088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68089       };
68090     } catch (...) {
68091       {
68092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68093       };
68094     }
68095   }
68096
68097   jresult = result;
68098   return jresult;
68099 }
68100
68101
68102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68103   void * jresult ;
68104   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68105
68106   {
68107     try {
68108       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68109     } catch (std::out_of_range& e) {
68110       {
68111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68112       };
68113     } catch (std::exception& e) {
68114       {
68115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68116       };
68117     } catch (Dali::DaliException e) {
68118       {
68119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68120       };
68121     } catch (...) {
68122       {
68123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68124       };
68125     }
68126   }
68127
68128   jresult = (void *)result;
68129   return jresult;
68130 }
68131
68132
68133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68134   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68135
68136   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68137   {
68138     try {
68139       delete arg1;
68140     } catch (std::out_of_range& e) {
68141       {
68142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68143       };
68144     } catch (std::exception& e) {
68145       {
68146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68147       };
68148     } catch (Dali::DaliException e) {
68149       {
68150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68151       };
68152     } catch (...) {
68153       {
68154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68155       };
68156     }
68157   }
68158
68159 }
68160
68161
68162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68163   void * jresult ;
68164   Dali::Toolkit::KeyInputFocusManager result;
68165
68166   {
68167     try {
68168       result = Dali::Toolkit::KeyInputFocusManager::Get();
68169     } catch (std::out_of_range& e) {
68170       {
68171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68172       };
68173     } catch (std::exception& e) {
68174       {
68175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68176       };
68177     } catch (Dali::DaliException e) {
68178       {
68179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68180       };
68181     } catch (...) {
68182       {
68183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68184       };
68185     }
68186   }
68187
68188   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68189   return jresult;
68190 }
68191
68192
68193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68194   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68195   Dali::Toolkit::Control arg2 ;
68196   Dali::Toolkit::Control *argp2 ;
68197
68198   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68199   argp2 = (Dali::Toolkit::Control *)jarg2;
68200   if (!argp2) {
68201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68202     return ;
68203   }
68204   arg2 = *argp2;
68205   {
68206     try {
68207       (arg1)->SetFocus(arg2);
68208     } catch (std::out_of_range& e) {
68209       {
68210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68211       };
68212     } catch (std::exception& e) {
68213       {
68214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68215       };
68216     } catch (Dali::DaliException e) {
68217       {
68218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68219       };
68220     } catch (...) {
68221       {
68222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68223       };
68224     }
68225   }
68226
68227 }
68228
68229
68230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68231   void * jresult ;
68232   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68233   Dali::Toolkit::Control result;
68234
68235   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68236   {
68237     try {
68238       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68239     } catch (std::out_of_range& e) {
68240       {
68241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68242       };
68243     } catch (std::exception& e) {
68244       {
68245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68246       };
68247     } catch (Dali::DaliException e) {
68248       {
68249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68250       };
68251     } catch (...) {
68252       {
68253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68254       };
68255     }
68256   }
68257
68258   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68259   return jresult;
68260 }
68261
68262
68263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68264   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68265   Dali::Toolkit::Control arg2 ;
68266   Dali::Toolkit::Control *argp2 ;
68267
68268   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68269   argp2 = (Dali::Toolkit::Control *)jarg2;
68270   if (!argp2) {
68271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68272     return ;
68273   }
68274   arg2 = *argp2;
68275   {
68276     try {
68277       (arg1)->RemoveFocus(arg2);
68278     } catch (std::out_of_range& e) {
68279       {
68280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68281       };
68282     } catch (std::exception& e) {
68283       {
68284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68285       };
68286     } catch (Dali::DaliException e) {
68287       {
68288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68289       };
68290     } catch (...) {
68291       {
68292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68293       };
68294     }
68295   }
68296
68297 }
68298
68299
68300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68301   void * jresult ;
68302   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68303   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68304
68305   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68306   {
68307     try {
68308       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68309     } catch (std::out_of_range& e) {
68310       {
68311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68312       };
68313     } catch (std::exception& e) {
68314       {
68315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68316       };
68317     } catch (Dali::DaliException e) {
68318       {
68319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68320       };
68321     } catch (...) {
68322       {
68323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68324       };
68325     }
68326   }
68327
68328   jresult = (void *)result;
68329   return jresult;
68330 }
68331
68332
68333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68334   void * jresult ;
68335   Dali::Toolkit::Alignment::Padding *result = 0 ;
68336
68337   {
68338     try {
68339       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68340     } catch (std::out_of_range& e) {
68341       {
68342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68343       };
68344     } catch (std::exception& e) {
68345       {
68346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68347       };
68348     } catch (Dali::DaliException e) {
68349       {
68350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68351       };
68352     } catch (...) {
68353       {
68354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68355       };
68356     }
68357   }
68358
68359   jresult = (void *)result;
68360   return jresult;
68361 }
68362
68363
68364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68365   void * jresult ;
68366   float arg1 ;
68367   float arg2 ;
68368   float arg3 ;
68369   float arg4 ;
68370   Dali::Toolkit::Alignment::Padding *result = 0 ;
68371
68372   arg1 = (float)jarg1;
68373   arg2 = (float)jarg2;
68374   arg3 = (float)jarg3;
68375   arg4 = (float)jarg4;
68376   {
68377     try {
68378       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68379     } catch (std::out_of_range& e) {
68380       {
68381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68382       };
68383     } catch (std::exception& e) {
68384       {
68385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68386       };
68387     } catch (Dali::DaliException e) {
68388       {
68389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68390       };
68391     } catch (...) {
68392       {
68393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68394       };
68395     }
68396   }
68397
68398   jresult = (void *)result;
68399   return jresult;
68400 }
68401
68402
68403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68404   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68405   float arg2 ;
68406
68407   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68408   arg2 = (float)jarg2;
68409   if (arg1) (arg1)->left = arg2;
68410 }
68411
68412
68413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68414   float jresult ;
68415   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68416   float result;
68417
68418   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68419   result = (float) ((arg1)->left);
68420   jresult = result;
68421   return jresult;
68422 }
68423
68424
68425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68426   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68427   float arg2 ;
68428
68429   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68430   arg2 = (float)jarg2;
68431   if (arg1) (arg1)->right = arg2;
68432 }
68433
68434
68435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68436   float jresult ;
68437   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68438   float result;
68439
68440   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68441   result = (float) ((arg1)->right);
68442   jresult = result;
68443   return jresult;
68444 }
68445
68446
68447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68448   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68449   float arg2 ;
68450
68451   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68452   arg2 = (float)jarg2;
68453   if (arg1) (arg1)->top = arg2;
68454 }
68455
68456
68457 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68458   float jresult ;
68459   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68460   float result;
68461
68462   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68463   result = (float) ((arg1)->top);
68464   jresult = result;
68465   return jresult;
68466 }
68467
68468
68469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68470   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68471   float arg2 ;
68472
68473   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68474   arg2 = (float)jarg2;
68475   if (arg1) (arg1)->bottom = arg2;
68476 }
68477
68478
68479 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68480   float jresult ;
68481   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68482   float result;
68483
68484   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68485   result = (float) ((arg1)->bottom);
68486   jresult = result;
68487   return jresult;
68488 }
68489
68490
68491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68492   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68493
68494   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68495   {
68496     try {
68497       delete arg1;
68498     } catch (std::out_of_range& e) {
68499       {
68500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68501       };
68502     } catch (std::exception& e) {
68503       {
68504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68505       };
68506     } catch (Dali::DaliException e) {
68507       {
68508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68509       };
68510     } catch (...) {
68511       {
68512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68513       };
68514     }
68515   }
68516
68517 }
68518
68519
68520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68521   void * jresult ;
68522   Dali::Toolkit::Alignment *result = 0 ;
68523
68524   {
68525     try {
68526       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68527     } catch (std::out_of_range& e) {
68528       {
68529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68530       };
68531     } catch (std::exception& e) {
68532       {
68533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68534       };
68535     } catch (Dali::DaliException e) {
68536       {
68537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68538       };
68539     } catch (...) {
68540       {
68541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68542       };
68543     }
68544   }
68545
68546   jresult = (void *)result;
68547   return jresult;
68548 }
68549
68550
68551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68552   void * jresult ;
68553   Dali::Toolkit::Alignment::Type arg1 ;
68554   Dali::Toolkit::Alignment::Type arg2 ;
68555   Dali::Toolkit::Alignment result;
68556
68557   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68558   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68559   {
68560     try {
68561       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68562     } catch (std::out_of_range& e) {
68563       {
68564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68565       };
68566     } catch (std::exception& e) {
68567       {
68568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68569       };
68570     } catch (Dali::DaliException e) {
68571       {
68572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68573       };
68574     } catch (...) {
68575       {
68576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68577       };
68578     }
68579   }
68580
68581   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68582   return jresult;
68583 }
68584
68585
68586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68587   void * jresult ;
68588   Dali::Toolkit::Alignment::Type arg1 ;
68589   Dali::Toolkit::Alignment result;
68590
68591   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68592   {
68593     try {
68594       result = Dali::Toolkit::Alignment::New(arg1);
68595     } catch (std::out_of_range& e) {
68596       {
68597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68598       };
68599     } catch (std::exception& e) {
68600       {
68601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68602       };
68603     } catch (Dali::DaliException e) {
68604       {
68605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68606       };
68607     } catch (...) {
68608       {
68609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68610       };
68611     }
68612   }
68613
68614   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68615   return jresult;
68616 }
68617
68618
68619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68620   void * jresult ;
68621   Dali::Toolkit::Alignment result;
68622
68623   {
68624     try {
68625       result = Dali::Toolkit::Alignment::New();
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 = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68646   return jresult;
68647 }
68648
68649
68650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68651   void * jresult ;
68652   Dali::Toolkit::Alignment *arg1 = 0 ;
68653   Dali::Toolkit::Alignment *result = 0 ;
68654
68655   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68656   if (!arg1) {
68657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68658     return 0;
68659   }
68660   {
68661     try {
68662       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68663     } catch (std::out_of_range& e) {
68664       {
68665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68666       };
68667     } catch (std::exception& e) {
68668       {
68669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68670       };
68671     } catch (Dali::DaliException e) {
68672       {
68673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68674       };
68675     } catch (...) {
68676       {
68677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68678       };
68679     }
68680   }
68681
68682   jresult = (void *)result;
68683   return jresult;
68684 }
68685
68686
68687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68688   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68689
68690   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68691   {
68692     try {
68693       delete arg1;
68694     } catch (std::out_of_range& e) {
68695       {
68696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68697       };
68698     } catch (std::exception& e) {
68699       {
68700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68701       };
68702     } catch (Dali::DaliException e) {
68703       {
68704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68705       };
68706     } catch (...) {
68707       {
68708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68709       };
68710     }
68711   }
68712
68713 }
68714
68715
68716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68717   void * jresult ;
68718   Dali::BaseHandle arg1 ;
68719   Dali::BaseHandle *argp1 ;
68720   Dali::Toolkit::Alignment result;
68721
68722   argp1 = (Dali::BaseHandle *)jarg1;
68723   if (!argp1) {
68724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68725     return 0;
68726   }
68727   arg1 = *argp1;
68728   {
68729     try {
68730       result = Dali::Toolkit::Alignment::DownCast(arg1);
68731     } catch (std::out_of_range& e) {
68732       {
68733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68734       };
68735     } catch (std::exception& e) {
68736       {
68737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68738       };
68739     } catch (Dali::DaliException e) {
68740       {
68741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68742       };
68743     } catch (...) {
68744       {
68745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68746       };
68747     }
68748   }
68749
68750   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68751   return jresult;
68752 }
68753
68754
68755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68756   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68757   Dali::Toolkit::Alignment::Type arg2 ;
68758
68759   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68760   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68761   {
68762     try {
68763       (arg1)->SetAlignmentType(arg2);
68764     } catch (std::out_of_range& e) {
68765       {
68766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68767       };
68768     } catch (std::exception& e) {
68769       {
68770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68771       };
68772     } catch (Dali::DaliException e) {
68773       {
68774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68775       };
68776     } catch (...) {
68777       {
68778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68779       };
68780     }
68781   }
68782
68783 }
68784
68785
68786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68787   int jresult ;
68788   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68789   Dali::Toolkit::Alignment::Type result;
68790
68791   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68792   {
68793     try {
68794       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68795     } catch (std::out_of_range& e) {
68796       {
68797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68798       };
68799     } catch (std::exception& e) {
68800       {
68801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68802       };
68803     } catch (Dali::DaliException e) {
68804       {
68805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68806       };
68807     } catch (...) {
68808       {
68809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68810       };
68811     }
68812   }
68813
68814   jresult = (int)result;
68815   return jresult;
68816 }
68817
68818
68819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68820   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68821   Dali::Toolkit::Alignment::Scaling arg2 ;
68822
68823   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68824   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68825   {
68826     try {
68827       (arg1)->SetScaling(arg2);
68828     } catch (std::out_of_range& e) {
68829       {
68830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68831       };
68832     } catch (std::exception& e) {
68833       {
68834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68835       };
68836     } catch (Dali::DaliException e) {
68837       {
68838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68839       };
68840     } catch (...) {
68841       {
68842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68843       };
68844     }
68845   }
68846
68847 }
68848
68849
68850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68851   int jresult ;
68852   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68853   Dali::Toolkit::Alignment::Scaling result;
68854
68855   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68856   {
68857     try {
68858       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68859     } catch (std::out_of_range& e) {
68860       {
68861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68862       };
68863     } catch (std::exception& e) {
68864       {
68865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68866       };
68867     } catch (Dali::DaliException e) {
68868       {
68869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68870       };
68871     } catch (...) {
68872       {
68873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68874       };
68875     }
68876   }
68877
68878   jresult = (int)result;
68879   return jresult;
68880 }
68881
68882
68883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68884   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68885   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68886
68887   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68888   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68889   if (!arg2) {
68890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68891     return ;
68892   }
68893   {
68894     try {
68895       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68896     } catch (std::out_of_range& e) {
68897       {
68898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68899       };
68900     } catch (std::exception& e) {
68901       {
68902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68903       };
68904     } catch (Dali::DaliException e) {
68905       {
68906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68907       };
68908     } catch (...) {
68909       {
68910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68911       };
68912     }
68913   }
68914
68915 }
68916
68917
68918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68919   void * jresult ;
68920   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68921   Dali::Toolkit::Alignment::Padding *result = 0 ;
68922
68923   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68924   {
68925     try {
68926       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68927     } catch (std::out_of_range& e) {
68928       {
68929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68930       };
68931     } catch (std::exception& e) {
68932       {
68933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68934       };
68935     } catch (Dali::DaliException e) {
68936       {
68937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68938       };
68939     } catch (...) {
68940       {
68941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68942       };
68943     }
68944   }
68945
68946   jresult = (void *)result;
68947   return jresult;
68948 }
68949
68950
68951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68952   void * jresult ;
68953   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68954   Dali::Toolkit::Alignment *arg2 = 0 ;
68955   Dali::Toolkit::Alignment *result = 0 ;
68956
68957   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68958   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68959   if (!arg2) {
68960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68961     return 0;
68962   }
68963   {
68964     try {
68965       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68966     } catch (std::out_of_range& e) {
68967       {
68968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68969       };
68970     } catch (std::exception& e) {
68971       {
68972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68973       };
68974     } catch (Dali::DaliException e) {
68975       {
68976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68977       };
68978     } catch (...) {
68979       {
68980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68981       };
68982     }
68983   }
68984
68985   jresult = (void *)result;
68986   return jresult;
68987 }
68988
68989
68990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68991   int jresult ;
68992   int result;
68993
68994   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68995   jresult = (int)result;
68996   return jresult;
68997 }
68998
68999
69000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69001   int jresult ;
69002   int result;
69003
69004   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69005   jresult = (int)result;
69006   return jresult;
69007 }
69008
69009
69010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69011   int jresult ;
69012   int result;
69013
69014   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69015   jresult = (int)result;
69016   return jresult;
69017 }
69018
69019
69020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69021   int jresult ;
69022   int result;
69023
69024   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69025   jresult = (int)result;
69026   return jresult;
69027 }
69028
69029
69030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69031   int jresult ;
69032   int result;
69033
69034   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69035   jresult = (int)result;
69036   return jresult;
69037 }
69038
69039
69040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69041   int jresult ;
69042   int result;
69043
69044   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69045   jresult = (int)result;
69046   return jresult;
69047 }
69048
69049
69050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69051   int jresult ;
69052   int result;
69053
69054   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69055   jresult = (int)result;
69056   return jresult;
69057 }
69058
69059
69060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69061   int jresult ;
69062   int result;
69063
69064   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69065   jresult = (int)result;
69066   return jresult;
69067 }
69068
69069
69070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69071   int jresult ;
69072   int result;
69073
69074   result = (int)Dali::Toolkit::Button::Property::LABEL;
69075   jresult = (int)result;
69076   return jresult;
69077 }
69078
69079
69080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69081   int jresult ;
69082   int result;
69083
69084   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69085   jresult = (int)result;
69086   return jresult;
69087 }
69088
69089
69090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69091   void * jresult ;
69092   Dali::Toolkit::Button::Property *result = 0 ;
69093
69094   {
69095     try {
69096       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69097     } catch (std::out_of_range& e) {
69098       {
69099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69100       };
69101     } catch (std::exception& e) {
69102       {
69103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69104       };
69105     } catch (Dali::DaliException e) {
69106       {
69107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69108       };
69109     } catch (...) {
69110       {
69111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69112       };
69113     }
69114   }
69115
69116   jresult = (void *)result;
69117   return jresult;
69118 }
69119
69120
69121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69122   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69123
69124   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69125   {
69126     try {
69127       delete arg1;
69128     } catch (std::out_of_range& e) {
69129       {
69130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69131       };
69132     } catch (std::exception& e) {
69133       {
69134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69135       };
69136     } catch (Dali::DaliException e) {
69137       {
69138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69139       };
69140     } catch (...) {
69141       {
69142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69143       };
69144     }
69145   }
69146
69147 }
69148
69149
69150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69151   void * jresult ;
69152   Dali::Toolkit::Button *result = 0 ;
69153
69154   {
69155     try {
69156       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69157     } catch (std::out_of_range& e) {
69158       {
69159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69160       };
69161     } catch (std::exception& e) {
69162       {
69163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69164       };
69165     } catch (Dali::DaliException e) {
69166       {
69167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69168       };
69169     } catch (...) {
69170       {
69171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69172       };
69173     }
69174   }
69175
69176   jresult = (void *)result;
69177   return jresult;
69178 }
69179
69180
69181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69182   void * jresult ;
69183   Dali::Toolkit::Button *arg1 = 0 ;
69184   Dali::Toolkit::Button *result = 0 ;
69185
69186   arg1 = (Dali::Toolkit::Button *)jarg1;
69187   if (!arg1) {
69188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69189     return 0;
69190   }
69191   {
69192     try {
69193       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69194     } catch (std::out_of_range& e) {
69195       {
69196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69197       };
69198     } catch (std::exception& e) {
69199       {
69200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69201       };
69202     } catch (Dali::DaliException e) {
69203       {
69204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69205       };
69206     } catch (...) {
69207       {
69208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69209       };
69210     }
69211   }
69212
69213   jresult = (void *)result;
69214   return jresult;
69215 }
69216
69217
69218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69219   void * jresult ;
69220   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69221   Dali::Toolkit::Button *arg2 = 0 ;
69222   Dali::Toolkit::Button *result = 0 ;
69223
69224   arg1 = (Dali::Toolkit::Button *)jarg1;
69225   arg2 = (Dali::Toolkit::Button *)jarg2;
69226   if (!arg2) {
69227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69228     return 0;
69229   }
69230   {
69231     try {
69232       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69233     } catch (std::out_of_range& e) {
69234       {
69235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69236       };
69237     } catch (std::exception& e) {
69238       {
69239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69240       };
69241     } catch (Dali::DaliException e) {
69242       {
69243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69244       };
69245     } catch (...) {
69246       {
69247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69248       };
69249     }
69250   }
69251
69252   jresult = (void *)result;
69253   return jresult;
69254 }
69255
69256
69257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69258   void * jresult ;
69259   Dali::BaseHandle arg1 ;
69260   Dali::BaseHandle *argp1 ;
69261   Dali::Toolkit::Button result;
69262
69263   argp1 = (Dali::BaseHandle *)jarg1;
69264   if (!argp1) {
69265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69266     return 0;
69267   }
69268   arg1 = *argp1;
69269   {
69270     try {
69271       result = Dali::Toolkit::Button::DownCast(arg1);
69272     } catch (std::out_of_range& e) {
69273       {
69274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69275       };
69276     } catch (std::exception& e) {
69277       {
69278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69279       };
69280     } catch (Dali::DaliException e) {
69281       {
69282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69283       };
69284     } catch (...) {
69285       {
69286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69287       };
69288     }
69289   }
69290
69291   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69292   return jresult;
69293 }
69294
69295
69296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69297   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69298
69299   arg1 = (Dali::Toolkit::Button *)jarg1;
69300   {
69301     try {
69302       delete arg1;
69303     } catch (std::out_of_range& e) {
69304       {
69305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69306       };
69307     } catch (std::exception& e) {
69308       {
69309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69310       };
69311     } catch (Dali::DaliException e) {
69312       {
69313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69314       };
69315     } catch (...) {
69316       {
69317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69318       };
69319     }
69320   }
69321
69322 }
69323
69324
69325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69326   unsigned int jresult ;
69327   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69328   bool result;
69329
69330   arg1 = (Dali::Toolkit::Button *)jarg1;
69331   {
69332     try {
69333       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69334     } catch (std::out_of_range& e) {
69335       {
69336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69337       };
69338     } catch (std::exception& e) {
69339       {
69340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69341       };
69342     } catch (Dali::DaliException e) {
69343       {
69344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69345       };
69346     } catch (...) {
69347       {
69348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69349       };
69350     }
69351   }
69352
69353   jresult = result;
69354   return jresult;
69355 }
69356
69357
69358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69359   unsigned int jresult ;
69360   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69361   bool result;
69362
69363   arg1 = (Dali::Toolkit::Button *)jarg1;
69364   {
69365     try {
69366       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69367     } catch (std::out_of_range& e) {
69368       {
69369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69370       };
69371     } catch (std::exception& e) {
69372       {
69373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69374       };
69375     } catch (Dali::DaliException e) {
69376       {
69377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69378       };
69379     } catch (...) {
69380       {
69381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69382       };
69383     }
69384   }
69385
69386   jresult = result;
69387   return jresult;
69388 }
69389
69390
69391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69392   float jresult ;
69393   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69394   float result;
69395
69396   arg1 = (Dali::Toolkit::Button *)jarg1;
69397   {
69398     try {
69399       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69400     } catch (std::out_of_range& e) {
69401       {
69402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69403       };
69404     } catch (std::exception& e) {
69405       {
69406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69407       };
69408     } catch (Dali::DaliException e) {
69409       {
69410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69411       };
69412     } catch (...) {
69413       {
69414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69415       };
69416     }
69417   }
69418
69419   jresult = result;
69420   return jresult;
69421 }
69422
69423
69424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69425   float jresult ;
69426   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69427   float result;
69428
69429   arg1 = (Dali::Toolkit::Button *)jarg1;
69430   {
69431     try {
69432       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69433     } catch (std::out_of_range& e) {
69434       {
69435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69436       };
69437     } catch (std::exception& e) {
69438       {
69439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69440       };
69441     } catch (Dali::DaliException e) {
69442       {
69443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69444       };
69445     } catch (...) {
69446       {
69447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69448       };
69449     }
69450   }
69451
69452   jresult = result;
69453   return jresult;
69454 }
69455
69456
69457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69458   unsigned int jresult ;
69459   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69460   bool result;
69461
69462   arg1 = (Dali::Toolkit::Button *)jarg1;
69463   {
69464     try {
69465       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69466     } catch (std::out_of_range& e) {
69467       {
69468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69469       };
69470     } catch (std::exception& e) {
69471       {
69472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69473       };
69474     } catch (Dali::DaliException e) {
69475       {
69476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69477       };
69478     } catch (...) {
69479       {
69480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69481       };
69482     }
69483   }
69484
69485   jresult = result;
69486   return jresult;
69487 }
69488
69489
69490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69491   unsigned int jresult ;
69492   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69493   bool result;
69494
69495   arg1 = (Dali::Toolkit::Button *)jarg1;
69496   {
69497     try {
69498       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69499     } catch (std::out_of_range& e) {
69500       {
69501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69502       };
69503     } catch (std::exception& e) {
69504       {
69505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69506       };
69507     } catch (Dali::DaliException e) {
69508       {
69509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69510       };
69511     } catch (...) {
69512       {
69513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69514       };
69515     }
69516   }
69517
69518   jresult = result;
69519   return jresult;
69520 }
69521
69522
69523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69524   float jresult ;
69525   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69526   float result;
69527
69528   arg1 = (Dali::Toolkit::Button *)jarg1;
69529   {
69530     try {
69531       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69532     } catch (std::out_of_range& e) {
69533       {
69534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69535       };
69536     } catch (std::exception& e) {
69537       {
69538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69539       };
69540     } catch (Dali::DaliException e) {
69541       {
69542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69543       };
69544     } catch (...) {
69545       {
69546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69547       };
69548     }
69549   }
69550
69551   jresult = result;
69552   return jresult;
69553 }
69554
69555
69556 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69557   char * jresult ;
69558   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69559   std::string result;
69560
69561   arg1 = (Dali::Toolkit::Button *)jarg1;
69562   {
69563     try {
69564       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69565     } catch (std::out_of_range& e) {
69566       {
69567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69568       };
69569     } catch (std::exception& e) {
69570       {
69571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69572       };
69573     } catch (Dali::DaliException e) {
69574       {
69575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69576       };
69577     } catch (...) {
69578       {
69579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69580       };
69581     }
69582   }
69583
69584   jresult = SWIG_csharp_string_callback((&result)->c_str());
69585   return jresult;
69586 }
69587
69588
69589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69590   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69591   Dali::Actor arg2 ;
69592   Dali::Actor *argp2 ;
69593
69594   arg1 = (Dali::Toolkit::Button *)jarg1;
69595   argp2 = (Dali::Actor *)jarg2;
69596   if (!argp2) {
69597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69598     return ;
69599   }
69600   arg2 = *argp2;
69601   {
69602     try {
69603       (arg1)->SetLabel(arg2);
69604     } catch (std::out_of_range& e) {
69605       {
69606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69607       };
69608     } catch (std::exception& e) {
69609       {
69610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69611       };
69612     } catch (Dali::DaliException e) {
69613       {
69614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69615       };
69616     } catch (...) {
69617       {
69618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69619       };
69620     }
69621   }
69622
69623 }
69624
69625
69626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69627   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69628   Dali::Image arg2 ;
69629   Dali::Image *argp2 ;
69630
69631   arg1 = (Dali::Toolkit::Button *)jarg1;
69632   argp2 = (Dali::Image *)jarg2;
69633   if (!argp2) {
69634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69635     return ;
69636   }
69637   arg2 = *argp2;
69638   {
69639     try {
69640       (arg1)->SetButtonImage(arg2);
69641     } catch (std::out_of_range& e) {
69642       {
69643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69644       };
69645     } catch (std::exception& e) {
69646       {
69647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69648       };
69649     } catch (Dali::DaliException e) {
69650       {
69651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69652       };
69653     } catch (...) {
69654       {
69655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69656       };
69657     }
69658   }
69659
69660 }
69661
69662
69663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69664   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69665   Dali::Image arg2 ;
69666   Dali::Image *argp2 ;
69667
69668   arg1 = (Dali::Toolkit::Button *)jarg1;
69669   argp2 = (Dali::Image *)jarg2;
69670   if (!argp2) {
69671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69672     return ;
69673   }
69674   arg2 = *argp2;
69675   {
69676     try {
69677       (arg1)->SetSelectedImage(arg2);
69678     } catch (std::out_of_range& e) {
69679       {
69680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69681       };
69682     } catch (std::exception& e) {
69683       {
69684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69685       };
69686     } catch (Dali::DaliException e) {
69687       {
69688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69689       };
69690     } catch (...) {
69691       {
69692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69693       };
69694     }
69695   }
69696
69697 }
69698
69699
69700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69701   void * jresult ;
69702   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69703   Dali::Actor result;
69704
69705   arg1 = (Dali::Toolkit::Button *)jarg1;
69706   {
69707     try {
69708       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
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 = new Dali::Actor((const Dali::Actor &)result);
69729   return jresult;
69730 }
69731
69732
69733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69734   void * jresult ;
69735   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69736   Dali::Actor result;
69737
69738   arg1 = (Dali::Toolkit::Button *)jarg1;
69739   {
69740     try {
69741       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69742     } catch (std::out_of_range& e) {
69743       {
69744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69745       };
69746     } catch (std::exception& e) {
69747       {
69748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69749       };
69750     } catch (Dali::DaliException e) {
69751       {
69752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69753       };
69754     } catch (...) {
69755       {
69756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69757       };
69758     }
69759   }
69760
69761   jresult = new Dali::Actor((const Dali::Actor &)result);
69762   return jresult;
69763 }
69764
69765
69766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69767   void * jresult ;
69768   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69769   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69770
69771   arg1 = (Dali::Toolkit::Button *)jarg1;
69772   {
69773     try {
69774       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69775     } catch (std::out_of_range& e) {
69776       {
69777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69778       };
69779     } catch (std::exception& e) {
69780       {
69781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69782       };
69783     } catch (Dali::DaliException e) {
69784       {
69785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69786       };
69787     } catch (...) {
69788       {
69789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69790       };
69791     }
69792   }
69793
69794   jresult = (void *)result;
69795   return jresult;
69796 }
69797
69798
69799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69800   void * jresult ;
69801   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69802   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69803
69804   arg1 = (Dali::Toolkit::Button *)jarg1;
69805   {
69806     try {
69807       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69808     } catch (std::out_of_range& e) {
69809       {
69810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69811       };
69812     } catch (std::exception& e) {
69813       {
69814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69815       };
69816     } catch (Dali::DaliException e) {
69817       {
69818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69819       };
69820     } catch (...) {
69821       {
69822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69823       };
69824     }
69825   }
69826
69827   jresult = (void *)result;
69828   return jresult;
69829 }
69830
69831
69832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69833   void * jresult ;
69834   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69835   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69836
69837   arg1 = (Dali::Toolkit::Button *)jarg1;
69838   {
69839     try {
69840       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69841     } catch (std::out_of_range& e) {
69842       {
69843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69844       };
69845     } catch (std::exception& e) {
69846       {
69847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69848       };
69849     } catch (Dali::DaliException e) {
69850       {
69851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69852       };
69853     } catch (...) {
69854       {
69855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69856       };
69857     }
69858   }
69859
69860   jresult = (void *)result;
69861   return jresult;
69862 }
69863
69864
69865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69866   void * jresult ;
69867   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69868   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69869
69870   arg1 = (Dali::Toolkit::Button *)jarg1;
69871   {
69872     try {
69873       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69874     } catch (std::out_of_range& e) {
69875       {
69876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69877       };
69878     } catch (std::exception& e) {
69879       {
69880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69881       };
69882     } catch (Dali::DaliException e) {
69883       {
69884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69885       };
69886     } catch (...) {
69887       {
69888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69889       };
69890     }
69891   }
69892
69893   jresult = (void *)result;
69894   return jresult;
69895 }
69896
69897
69898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69899   void * jresult ;
69900   Dali::Toolkit::CheckBoxButton *result = 0 ;
69901
69902   {
69903     try {
69904       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69905     } catch (std::out_of_range& e) {
69906       {
69907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69908       };
69909     } catch (std::exception& e) {
69910       {
69911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69912       };
69913     } catch (Dali::DaliException e) {
69914       {
69915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69916       };
69917     } catch (...) {
69918       {
69919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69920       };
69921     }
69922   }
69923
69924   jresult = (void *)result;
69925   return jresult;
69926 }
69927
69928
69929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69930   void * jresult ;
69931   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69932   Dali::Toolkit::CheckBoxButton *result = 0 ;
69933
69934   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69935   if (!arg1) {
69936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69937     return 0;
69938   }
69939   {
69940     try {
69941       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69942     } catch (std::out_of_range& e) {
69943       {
69944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69945       };
69946     } catch (std::exception& e) {
69947       {
69948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69949       };
69950     } catch (Dali::DaliException e) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69953       };
69954     } catch (...) {
69955       {
69956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69957       };
69958     }
69959   }
69960
69961   jresult = (void *)result;
69962   return jresult;
69963 }
69964
69965
69966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69967   void * jresult ;
69968   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69969   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69970   Dali::Toolkit::CheckBoxButton *result = 0 ;
69971
69972   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69973   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69974   if (!arg2) {
69975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69976     return 0;
69977   }
69978   {
69979     try {
69980       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69981     } catch (std::out_of_range& e) {
69982       {
69983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69984       };
69985     } catch (std::exception& e) {
69986       {
69987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69988       };
69989     } catch (Dali::DaliException e) {
69990       {
69991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69992       };
69993     } catch (...) {
69994       {
69995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69996       };
69997     }
69998   }
69999
70000   jresult = (void *)result;
70001   return jresult;
70002 }
70003
70004
70005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70006   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70007
70008   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70009   {
70010     try {
70011       delete arg1;
70012     } catch (std::out_of_range& e) {
70013       {
70014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70015       };
70016     } catch (std::exception& e) {
70017       {
70018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70019       };
70020     } catch (Dali::DaliException e) {
70021       {
70022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70023       };
70024     } catch (...) {
70025       {
70026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70027       };
70028     }
70029   }
70030
70031 }
70032
70033
70034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70035   void * jresult ;
70036   Dali::Toolkit::CheckBoxButton result;
70037
70038   {
70039     try {
70040       result = Dali::Toolkit::CheckBoxButton::New();
70041     } catch (std::out_of_range& e) {
70042       {
70043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70044       };
70045     } catch (std::exception& e) {
70046       {
70047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70048       };
70049     } catch (Dali::DaliException e) {
70050       {
70051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70052       };
70053     } catch (...) {
70054       {
70055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70056       };
70057     }
70058   }
70059
70060   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70061   return jresult;
70062 }
70063
70064
70065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70066   void * jresult ;
70067   Dali::BaseHandle arg1 ;
70068   Dali::BaseHandle *argp1 ;
70069   Dali::Toolkit::CheckBoxButton result;
70070
70071   argp1 = (Dali::BaseHandle *)jarg1;
70072   if (!argp1) {
70073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70074     return 0;
70075   }
70076   arg1 = *argp1;
70077   {
70078     try {
70079       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70080     } catch (std::out_of_range& e) {
70081       {
70082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70083       };
70084     } catch (std::exception& e) {
70085       {
70086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70087       };
70088     } catch (Dali::DaliException e) {
70089       {
70090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70091       };
70092     } catch (...) {
70093       {
70094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70095       };
70096     }
70097   }
70098
70099   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70100   return jresult;
70101 }
70102
70103
70104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70105   int jresult ;
70106   int result;
70107
70108   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70109   jresult = (int)result;
70110   return jresult;
70111 }
70112
70113
70114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70115   int jresult ;
70116   int result;
70117
70118   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70119   jresult = (int)result;
70120   return jresult;
70121 }
70122
70123
70124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70125   int jresult ;
70126   int result;
70127
70128   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70129   jresult = (int)result;
70130   return jresult;
70131 }
70132
70133
70134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70135   int jresult ;
70136   int result;
70137
70138   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70139   jresult = (int)result;
70140   return jresult;
70141 }
70142
70143
70144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70145   int jresult ;
70146   int result;
70147
70148   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70149   jresult = (int)result;
70150   return jresult;
70151 }
70152
70153
70154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70155   void * jresult ;
70156   Dali::Toolkit::PushButton::Property *result = 0 ;
70157
70158   {
70159     try {
70160       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70161     } catch (std::out_of_range& e) {
70162       {
70163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70164       };
70165     } catch (std::exception& e) {
70166       {
70167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70168       };
70169     } catch (Dali::DaliException e) {
70170       {
70171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70172       };
70173     } catch (...) {
70174       {
70175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70176       };
70177     }
70178   }
70179
70180   jresult = (void *)result;
70181   return jresult;
70182 }
70183
70184
70185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70186   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70187
70188   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70189   {
70190     try {
70191       delete arg1;
70192     } catch (std::out_of_range& e) {
70193       {
70194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70195       };
70196     } catch (std::exception& e) {
70197       {
70198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70199       };
70200     } catch (Dali::DaliException e) {
70201       {
70202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70203       };
70204     } catch (...) {
70205       {
70206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70207       };
70208     }
70209   }
70210
70211 }
70212
70213
70214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70215   void * jresult ;
70216   Dali::Toolkit::PushButton *result = 0 ;
70217
70218   {
70219     try {
70220       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
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_new_PushButton__SWIG_1(void * jarg1) {
70246   void * jresult ;
70247   Dali::Toolkit::PushButton *arg1 = 0 ;
70248   Dali::Toolkit::PushButton *result = 0 ;
70249
70250   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70251   if (!arg1) {
70252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70253     return 0;
70254   }
70255   {
70256     try {
70257       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70258     } catch (std::out_of_range& e) {
70259       {
70260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70261       };
70262     } catch (std::exception& e) {
70263       {
70264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70265       };
70266     } catch (Dali::DaliException e) {
70267       {
70268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70269       };
70270     } catch (...) {
70271       {
70272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70273       };
70274     }
70275   }
70276
70277   jresult = (void *)result;
70278   return jresult;
70279 }
70280
70281
70282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70283   void * jresult ;
70284   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70285   Dali::Toolkit::PushButton *arg2 = 0 ;
70286   Dali::Toolkit::PushButton *result = 0 ;
70287
70288   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70289   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70290   if (!arg2) {
70291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70292     return 0;
70293   }
70294   {
70295     try {
70296       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70297     } catch (std::out_of_range& e) {
70298       {
70299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70300       };
70301     } catch (std::exception& e) {
70302       {
70303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70304       };
70305     } catch (Dali::DaliException e) {
70306       {
70307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70308       };
70309     } catch (...) {
70310       {
70311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70312       };
70313     }
70314   }
70315
70316   jresult = (void *)result;
70317   return jresult;
70318 }
70319
70320
70321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70322   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70323
70324   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70325   {
70326     try {
70327       delete arg1;
70328     } catch (std::out_of_range& e) {
70329       {
70330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70331       };
70332     } catch (std::exception& e) {
70333       {
70334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70335       };
70336     } catch (Dali::DaliException e) {
70337       {
70338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70339       };
70340     } catch (...) {
70341       {
70342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70343       };
70344     }
70345   }
70346
70347 }
70348
70349
70350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70351   void * jresult ;
70352   Dali::Toolkit::PushButton result;
70353
70354   {
70355     try {
70356       result = Dali::Toolkit::PushButton::New();
70357     } catch (std::out_of_range& e) {
70358       {
70359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70360       };
70361     } catch (std::exception& e) {
70362       {
70363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70364       };
70365     } catch (Dali::DaliException e) {
70366       {
70367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70368       };
70369     } catch (...) {
70370       {
70371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70372       };
70373     }
70374   }
70375
70376   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70377   return jresult;
70378 }
70379
70380
70381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70382   void * jresult ;
70383   Dali::BaseHandle arg1 ;
70384   Dali::BaseHandle *argp1 ;
70385   Dali::Toolkit::PushButton result;
70386
70387   argp1 = (Dali::BaseHandle *)jarg1;
70388   if (!argp1) {
70389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70390     return 0;
70391   }
70392   arg1 = *argp1;
70393   {
70394     try {
70395       result = Dali::Toolkit::PushButton::DownCast(arg1);
70396     } catch (std::out_of_range& e) {
70397       {
70398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70399       };
70400     } catch (std::exception& e) {
70401       {
70402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70403       };
70404     } catch (Dali::DaliException e) {
70405       {
70406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70407       };
70408     } catch (...) {
70409       {
70410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70411       };
70412     }
70413   }
70414
70415   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70416   return jresult;
70417 }
70418
70419
70420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70421   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70422   Dali::Image arg2 ;
70423   Dali::Image *argp2 ;
70424
70425   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70426   argp2 = (Dali::Image *)jarg2;
70427   if (!argp2) {
70428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70429     return ;
70430   }
70431   arg2 = *argp2;
70432   {
70433     try {
70434       (arg1)->SetButtonImage(arg2);
70435     } catch (std::out_of_range& e) {
70436       {
70437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70438       };
70439     } catch (std::exception& e) {
70440       {
70441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70442       };
70443     } catch (Dali::DaliException e) {
70444       {
70445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70446       };
70447     } catch (...) {
70448       {
70449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70450       };
70451     }
70452   }
70453
70454 }
70455
70456
70457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70458   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70459   Dali::Actor arg2 ;
70460   Dali::Actor *argp2 ;
70461
70462   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70463   argp2 = (Dali::Actor *)jarg2;
70464   if (!argp2) {
70465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70466     return ;
70467   }
70468   arg2 = *argp2;
70469   {
70470     try {
70471       (arg1)->SetButtonImage(arg2);
70472     } catch (std::out_of_range& e) {
70473       {
70474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70475       };
70476     } catch (std::exception& e) {
70477       {
70478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70479       };
70480     } catch (Dali::DaliException e) {
70481       {
70482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70483       };
70484     } catch (...) {
70485       {
70486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70487       };
70488     }
70489   }
70490
70491 }
70492
70493
70494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70495   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70496   Dali::Actor arg2 ;
70497   Dali::Actor *argp2 ;
70498
70499   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70500   argp2 = (Dali::Actor *)jarg2;
70501   if (!argp2) {
70502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70503     return ;
70504   }
70505   arg2 = *argp2;
70506   {
70507     try {
70508       (arg1)->SetBackgroundImage(arg2);
70509     } catch (std::out_of_range& e) {
70510       {
70511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70512       };
70513     } catch (std::exception& e) {
70514       {
70515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70516       };
70517     } catch (Dali::DaliException e) {
70518       {
70519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70520       };
70521     } catch (...) {
70522       {
70523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70524       };
70525     }
70526   }
70527
70528 }
70529
70530
70531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70532   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70533   Dali::Image arg2 ;
70534   Dali::Image *argp2 ;
70535
70536   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70537   argp2 = (Dali::Image *)jarg2;
70538   if (!argp2) {
70539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70540     return ;
70541   }
70542   arg2 = *argp2;
70543   {
70544     try {
70545       (arg1)->SetSelectedImage(arg2);
70546     } catch (std::out_of_range& e) {
70547       {
70548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70549       };
70550     } catch (std::exception& e) {
70551       {
70552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70553       };
70554     } catch (Dali::DaliException e) {
70555       {
70556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70557       };
70558     } catch (...) {
70559       {
70560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70561       };
70562     }
70563   }
70564
70565 }
70566
70567
70568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70569   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70570   Dali::Actor arg2 ;
70571   Dali::Actor *argp2 ;
70572
70573   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70574   argp2 = (Dali::Actor *)jarg2;
70575   if (!argp2) {
70576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70577     return ;
70578   }
70579   arg2 = *argp2;
70580   {
70581     try {
70582       (arg1)->SetSelectedImage(arg2);
70583     } catch (std::out_of_range& e) {
70584       {
70585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70586       };
70587     } catch (std::exception& e) {
70588       {
70589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70590       };
70591     } catch (Dali::DaliException e) {
70592       {
70593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70594       };
70595     } catch (...) {
70596       {
70597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70598       };
70599     }
70600   }
70601
70602 }
70603
70604
70605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70606   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70607   Dali::Actor arg2 ;
70608   Dali::Actor *argp2 ;
70609
70610   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70611   argp2 = (Dali::Actor *)jarg2;
70612   if (!argp2) {
70613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70614     return ;
70615   }
70616   arg2 = *argp2;
70617   {
70618     try {
70619       (arg1)->SetSelectedBackgroundImage(arg2);
70620     } catch (std::out_of_range& e) {
70621       {
70622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70623       };
70624     } catch (std::exception& e) {
70625       {
70626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70627       };
70628     } catch (Dali::DaliException e) {
70629       {
70630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70631       };
70632     } catch (...) {
70633       {
70634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70635       };
70636     }
70637   }
70638
70639 }
70640
70641
70642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70643   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70644   Dali::Actor arg2 ;
70645   Dali::Actor *argp2 ;
70646
70647   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70648   argp2 = (Dali::Actor *)jarg2;
70649   if (!argp2) {
70650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70651     return ;
70652   }
70653   arg2 = *argp2;
70654   {
70655     try {
70656       (arg1)->SetDisabledBackgroundImage(arg2);
70657     } catch (std::out_of_range& e) {
70658       {
70659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70660       };
70661     } catch (std::exception& e) {
70662       {
70663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70664       };
70665     } catch (Dali::DaliException e) {
70666       {
70667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70668       };
70669     } catch (...) {
70670       {
70671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70672       };
70673     }
70674   }
70675
70676 }
70677
70678
70679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70680   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70681   Dali::Actor arg2 ;
70682   Dali::Actor *argp2 ;
70683
70684   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70685   argp2 = (Dali::Actor *)jarg2;
70686   if (!argp2) {
70687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70688     return ;
70689   }
70690   arg2 = *argp2;
70691   {
70692     try {
70693       (arg1)->SetDisabledImage(arg2);
70694     } catch (std::out_of_range& e) {
70695       {
70696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70697       };
70698     } catch (std::exception& e) {
70699       {
70700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70701       };
70702     } catch (Dali::DaliException e) {
70703       {
70704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70705       };
70706     } catch (...) {
70707       {
70708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70709       };
70710     }
70711   }
70712
70713 }
70714
70715
70716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70717   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70718   Dali::Actor arg2 ;
70719   Dali::Actor *argp2 ;
70720
70721   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70722   argp2 = (Dali::Actor *)jarg2;
70723   if (!argp2) {
70724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70725     return ;
70726   }
70727   arg2 = *argp2;
70728   {
70729     try {
70730       (arg1)->SetDisabledSelectedImage(arg2);
70731     } catch (std::out_of_range& e) {
70732       {
70733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70734       };
70735     } catch (std::exception& e) {
70736       {
70737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70738       };
70739     } catch (Dali::DaliException e) {
70740       {
70741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70742       };
70743     } catch (...) {
70744       {
70745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70746       };
70747     }
70748   }
70749
70750 }
70751
70752
70753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70754   void * jresult ;
70755   Dali::Toolkit::RadioButton *result = 0 ;
70756
70757   {
70758     try {
70759       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70760     } catch (std::out_of_range& e) {
70761       {
70762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70763       };
70764     } catch (std::exception& e) {
70765       {
70766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70767       };
70768     } catch (Dali::DaliException e) {
70769       {
70770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70771       };
70772     } catch (...) {
70773       {
70774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70775       };
70776     }
70777   }
70778
70779   jresult = (void *)result;
70780   return jresult;
70781 }
70782
70783
70784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
70785   void * jresult ;
70786   Dali::Toolkit::RadioButton *arg1 = 0 ;
70787   Dali::Toolkit::RadioButton *result = 0 ;
70788
70789   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70790   if (!arg1) {
70791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70792     return 0;
70793   }
70794   {
70795     try {
70796       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
70797     } catch (std::out_of_range& e) {
70798       {
70799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70800       };
70801     } catch (std::exception& e) {
70802       {
70803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70804       };
70805     } catch (Dali::DaliException e) {
70806       {
70807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70808       };
70809     } catch (...) {
70810       {
70811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70812       };
70813     }
70814   }
70815
70816   jresult = (void *)result;
70817   return jresult;
70818 }
70819
70820
70821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
70822   void * jresult ;
70823   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70824   Dali::Toolkit::RadioButton *arg2 = 0 ;
70825   Dali::Toolkit::RadioButton *result = 0 ;
70826
70827   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70828   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
70829   if (!arg2) {
70830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70831     return 0;
70832   }
70833   {
70834     try {
70835       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
70836     } catch (std::out_of_range& e) {
70837       {
70838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70839       };
70840     } catch (std::exception& e) {
70841       {
70842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70843       };
70844     } catch (Dali::DaliException e) {
70845       {
70846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70847       };
70848     } catch (...) {
70849       {
70850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70851       };
70852     }
70853   }
70854
70855   jresult = (void *)result;
70856   return jresult;
70857 }
70858
70859
70860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
70861   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70862
70863   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70864   {
70865     try {
70866       delete arg1;
70867     } catch (std::out_of_range& e) {
70868       {
70869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70870       };
70871     } catch (std::exception& e) {
70872       {
70873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70874       };
70875     } catch (Dali::DaliException e) {
70876       {
70877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70878       };
70879     } catch (...) {
70880       {
70881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70882       };
70883     }
70884   }
70885
70886 }
70887
70888
70889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
70890   void * jresult ;
70891   Dali::Toolkit::RadioButton result;
70892
70893   {
70894     try {
70895       result = Dali::Toolkit::RadioButton::New();
70896     } catch (std::out_of_range& e) {
70897       {
70898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70899       };
70900     } catch (std::exception& e) {
70901       {
70902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70903       };
70904     } catch (Dali::DaliException e) {
70905       {
70906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70907       };
70908     } catch (...) {
70909       {
70910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70911       };
70912     }
70913   }
70914
70915   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70916   return jresult;
70917 }
70918
70919
70920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
70921   void * jresult ;
70922   std::string *arg1 = 0 ;
70923   Dali::Toolkit::RadioButton result;
70924
70925   if (!jarg1) {
70926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70927     return 0;
70928   }
70929   std::string arg1_str(jarg1);
70930   arg1 = &arg1_str;
70931   {
70932     try {
70933       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70934     } catch (std::out_of_range& e) {
70935       {
70936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70937       };
70938     } catch (std::exception& e) {
70939       {
70940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70941       };
70942     } catch (Dali::DaliException e) {
70943       {
70944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70945       };
70946     } catch (...) {
70947       {
70948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70949       };
70950     }
70951   }
70952
70953   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70954
70955   //argout typemap for const std::string&
70956
70957   return jresult;
70958 }
70959
70960
70961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70962   void * jresult ;
70963   Dali::BaseHandle arg1 ;
70964   Dali::BaseHandle *argp1 ;
70965   Dali::Toolkit::RadioButton result;
70966
70967   argp1 = (Dali::BaseHandle *)jarg1;
70968   if (!argp1) {
70969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70970     return 0;
70971   }
70972   arg1 = *argp1;
70973   {
70974     try {
70975       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70976     } catch (std::out_of_range& e) {
70977       {
70978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70979       };
70980     } catch (std::exception& e) {
70981       {
70982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70983       };
70984     } catch (Dali::DaliException e) {
70985       {
70986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70987       };
70988     } catch (...) {
70989       {
70990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70991       };
70992     }
70993   }
70994
70995   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70996   return jresult;
70997 }
70998
70999
71000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71001   int jresult ;
71002   int result;
71003
71004   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71005   jresult = (int)result;
71006   return jresult;
71007 }
71008
71009
71010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71011   int jresult ;
71012   int result;
71013
71014   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71015   jresult = (int)result;
71016   return jresult;
71017 }
71018
71019
71020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71021   int jresult ;
71022   int result;
71023
71024   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71025   jresult = (int)result;
71026   return jresult;
71027 }
71028
71029
71030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71031   int jresult ;
71032   int result;
71033
71034   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71035   jresult = (int)result;
71036   return jresult;
71037 }
71038
71039
71040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71041   int jresult ;
71042   int result;
71043
71044   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71045   jresult = (int)result;
71046   return jresult;
71047 }
71048
71049
71050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71051   int jresult ;
71052   int result;
71053
71054   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71055   jresult = (int)result;
71056   return jresult;
71057 }
71058
71059
71060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71061   void * jresult ;
71062   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71063
71064   {
71065     try {
71066       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71067     } catch (std::out_of_range& e) {
71068       {
71069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71070       };
71071     } catch (std::exception& e) {
71072       {
71073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71074       };
71075     } catch (Dali::DaliException e) {
71076       {
71077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71078       };
71079     } catch (...) {
71080       {
71081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71082       };
71083     }
71084   }
71085
71086   jresult = (void *)result;
71087   return jresult;
71088 }
71089
71090
71091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71092   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71093
71094   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71095   {
71096     try {
71097       delete arg1;
71098     } catch (std::out_of_range& e) {
71099       {
71100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71101       };
71102     } catch (std::exception& e) {
71103       {
71104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71105       };
71106     } catch (Dali::DaliException e) {
71107       {
71108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71109       };
71110     } catch (...) {
71111       {
71112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71113       };
71114     }
71115   }
71116
71117 }
71118
71119
71120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71121   int jresult ;
71122   int result;
71123
71124   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71125   jresult = (int)result;
71126   return jresult;
71127 }
71128
71129
71130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71131   int jresult ;
71132   int result;
71133
71134   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71135   jresult = (int)result;
71136   return jresult;
71137 }
71138
71139
71140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71141   int jresult ;
71142   int result;
71143
71144   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71145   jresult = (int)result;
71146   return jresult;
71147 }
71148
71149
71150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71151   void * jresult ;
71152   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71153
71154   {
71155     try {
71156       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71157     } catch (std::out_of_range& e) {
71158       {
71159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71160       };
71161     } catch (std::exception& e) {
71162       {
71163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71164       };
71165     } catch (Dali::DaliException e) {
71166       {
71167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71168       };
71169     } catch (...) {
71170       {
71171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71172       };
71173     }
71174   }
71175
71176   jresult = (void *)result;
71177   return jresult;
71178 }
71179
71180
71181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71182   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71183
71184   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71185   {
71186     try {
71187       delete arg1;
71188     } catch (std::out_of_range& e) {
71189       {
71190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71191       };
71192     } catch (std::exception& e) {
71193       {
71194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71195       };
71196     } catch (Dali::DaliException e) {
71197       {
71198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71199       };
71200     } catch (...) {
71201       {
71202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71203       };
71204     }
71205   }
71206
71207 }
71208
71209
71210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71211   void * jresult ;
71212   Dali::Toolkit::FlexContainer *result = 0 ;
71213
71214   {
71215     try {
71216       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71217     } catch (std::out_of_range& e) {
71218       {
71219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71220       };
71221     } catch (std::exception& e) {
71222       {
71223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71224       };
71225     } catch (Dali::DaliException e) {
71226       {
71227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71228       };
71229     } catch (...) {
71230       {
71231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71232       };
71233     }
71234   }
71235
71236   jresult = (void *)result;
71237   return jresult;
71238 }
71239
71240
71241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71242   void * jresult ;
71243   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71244   Dali::Toolkit::FlexContainer *result = 0 ;
71245
71246   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71247   if (!arg1) {
71248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71249     return 0;
71250   }
71251   {
71252     try {
71253       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71254     } catch (std::out_of_range& e) {
71255       {
71256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71257       };
71258     } catch (std::exception& e) {
71259       {
71260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71261       };
71262     } catch (Dali::DaliException e) {
71263       {
71264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71265       };
71266     } catch (...) {
71267       {
71268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71269       };
71270     }
71271   }
71272
71273   jresult = (void *)result;
71274   return jresult;
71275 }
71276
71277
71278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71279   void * jresult ;
71280   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71281   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71282   Dali::Toolkit::FlexContainer *result = 0 ;
71283
71284   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71285   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71286   if (!arg2) {
71287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71288     return 0;
71289   }
71290   {
71291     try {
71292       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71293     } catch (std::out_of_range& e) {
71294       {
71295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71296       };
71297     } catch (std::exception& e) {
71298       {
71299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71300       };
71301     } catch (Dali::DaliException e) {
71302       {
71303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71304       };
71305     } catch (...) {
71306       {
71307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71308       };
71309     }
71310   }
71311
71312   jresult = (void *)result;
71313   return jresult;
71314 }
71315
71316
71317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71318   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71319
71320   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71321   {
71322     try {
71323       delete arg1;
71324     } catch (std::out_of_range& e) {
71325       {
71326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71327       };
71328     } catch (std::exception& e) {
71329       {
71330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71331       };
71332     } catch (Dali::DaliException e) {
71333       {
71334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71335       };
71336     } catch (...) {
71337       {
71338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71339       };
71340     }
71341   }
71342
71343 }
71344
71345
71346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71347   void * jresult ;
71348   Dali::Toolkit::FlexContainer result;
71349
71350   {
71351     try {
71352       result = Dali::Toolkit::FlexContainer::New();
71353     } catch (std::out_of_range& e) {
71354       {
71355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71356       };
71357     } catch (std::exception& e) {
71358       {
71359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71360       };
71361     } catch (Dali::DaliException e) {
71362       {
71363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71364       };
71365     } catch (...) {
71366       {
71367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71368       };
71369     }
71370   }
71371
71372   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71373   return jresult;
71374 }
71375
71376
71377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71378   void * jresult ;
71379   Dali::BaseHandle arg1 ;
71380   Dali::BaseHandle *argp1 ;
71381   Dali::Toolkit::FlexContainer result;
71382
71383   argp1 = (Dali::BaseHandle *)jarg1;
71384   if (!argp1) {
71385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71386     return 0;
71387   }
71388   arg1 = *argp1;
71389   {
71390     try {
71391       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71392     } catch (std::out_of_range& e) {
71393       {
71394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71395       };
71396     } catch (std::exception& e) {
71397       {
71398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71399       };
71400     } catch (Dali::DaliException e) {
71401       {
71402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71403       };
71404     } catch (...) {
71405       {
71406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71407       };
71408     }
71409   }
71410
71411   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71412   return jresult;
71413 }
71414
71415
71416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71417   int jresult ;
71418   int result;
71419
71420   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71421   jresult = (int)result;
71422   return jresult;
71423 }
71424
71425
71426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71427   int jresult ;
71428   int result;
71429
71430   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71431   jresult = (int)result;
71432   return jresult;
71433 }
71434
71435
71436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71437   int jresult ;
71438   int result;
71439
71440   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71441   jresult = (int)result;
71442   return jresult;
71443 }
71444
71445
71446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71447   int jresult ;
71448   int result;
71449
71450   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71451   jresult = (int)result;
71452   return jresult;
71453 }
71454
71455
71456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71457   void * jresult ;
71458   Dali::Toolkit::ImageView::Property *result = 0 ;
71459
71460   {
71461     try {
71462       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71463     } catch (std::out_of_range& e) {
71464       {
71465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71466       };
71467     } catch (std::exception& e) {
71468       {
71469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71470       };
71471     } catch (Dali::DaliException e) {
71472       {
71473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71474       };
71475     } catch (...) {
71476       {
71477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71478       };
71479     }
71480   }
71481
71482   jresult = (void *)result;
71483   return jresult;
71484 }
71485
71486
71487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71488   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71489
71490   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71491   {
71492     try {
71493       delete arg1;
71494     } catch (std::out_of_range& e) {
71495       {
71496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71497       };
71498     } catch (std::exception& e) {
71499       {
71500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71501       };
71502     } catch (Dali::DaliException e) {
71503       {
71504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71505       };
71506     } catch (...) {
71507       {
71508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71509       };
71510     }
71511   }
71512
71513 }
71514
71515
71516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71517   void * jresult ;
71518   Dali::Toolkit::ImageView *result = 0 ;
71519
71520   {
71521     try {
71522       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71523     } catch (std::out_of_range& e) {
71524       {
71525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71526       };
71527     } catch (std::exception& e) {
71528       {
71529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71530       };
71531     } catch (Dali::DaliException e) {
71532       {
71533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71534       };
71535     } catch (...) {
71536       {
71537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71538       };
71539     }
71540   }
71541
71542   jresult = (void *)result;
71543   return jresult;
71544 }
71545
71546
71547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71548   void * jresult ;
71549   Dali::Toolkit::ImageView result;
71550
71551   {
71552     try {
71553       result = Dali::Toolkit::ImageView::New();
71554     } catch (std::out_of_range& e) {
71555       {
71556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71557       };
71558     } catch (std::exception& e) {
71559       {
71560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71561       };
71562     } catch (Dali::DaliException e) {
71563       {
71564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71565       };
71566     } catch (...) {
71567       {
71568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71569       };
71570     }
71571   }
71572
71573   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71574   return jresult;
71575 }
71576
71577
71578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71579   void * jresult ;
71580   Dali::Image arg1 ;
71581   Dali::Image *argp1 ;
71582   Dali::Toolkit::ImageView result;
71583
71584   argp1 = (Dali::Image *)jarg1;
71585   if (!argp1) {
71586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71587     return 0;
71588   }
71589   arg1 = *argp1;
71590   {
71591     try {
71592       result = Dali::Toolkit::ImageView::New(arg1);
71593     } catch (std::out_of_range& e) {
71594       {
71595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71596       };
71597     } catch (std::exception& e) {
71598       {
71599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71600       };
71601     } catch (Dali::DaliException e) {
71602       {
71603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71604       };
71605     } catch (...) {
71606       {
71607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71608       };
71609     }
71610   }
71611
71612   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71613   return jresult;
71614 }
71615
71616
71617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71618   void * jresult ;
71619   std::string *arg1 = 0 ;
71620   Dali::Toolkit::ImageView result;
71621
71622   if (!jarg1) {
71623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71624     return 0;
71625   }
71626   std::string arg1_str(jarg1);
71627   arg1 = &arg1_str;
71628   {
71629     try {
71630       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71631     } catch (std::out_of_range& e) {
71632       {
71633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71634       };
71635     } catch (std::exception& e) {
71636       {
71637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71638       };
71639     } catch (Dali::DaliException e) {
71640       {
71641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71642       };
71643     } catch (...) {
71644       {
71645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71646       };
71647     }
71648   }
71649
71650   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71651
71652   //argout typemap for const std::string&
71653
71654   return jresult;
71655 }
71656
71657
71658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71659   void * jresult ;
71660   std::string *arg1 = 0 ;
71661   Dali::ImageDimensions arg2 ;
71662   Dali::ImageDimensions *argp2 ;
71663   Dali::Toolkit::ImageView result;
71664
71665   if (!jarg1) {
71666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71667     return 0;
71668   }
71669   std::string arg1_str(jarg1);
71670   arg1 = &arg1_str;
71671   argp2 = (Dali::ImageDimensions *)jarg2;
71672   if (!argp2) {
71673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71674     return 0;
71675   }
71676   arg2 = *argp2;
71677   {
71678     try {
71679       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71680     } catch (std::out_of_range& e) {
71681       {
71682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71683       };
71684     } catch (std::exception& e) {
71685       {
71686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71687       };
71688     } catch (Dali::DaliException e) {
71689       {
71690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71691       };
71692     } catch (...) {
71693       {
71694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71695       };
71696     }
71697   }
71698
71699   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71700
71701   //argout typemap for const std::string&
71702
71703   return jresult;
71704 }
71705
71706
71707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71708   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71709
71710   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71711   {
71712     try {
71713       delete arg1;
71714     } catch (std::out_of_range& e) {
71715       {
71716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71717       };
71718     } catch (std::exception& e) {
71719       {
71720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71721       };
71722     } catch (Dali::DaliException e) {
71723       {
71724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71725       };
71726     } catch (...) {
71727       {
71728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71729       };
71730     }
71731   }
71732
71733 }
71734
71735
71736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71737   void * jresult ;
71738   Dali::Toolkit::ImageView *arg1 = 0 ;
71739   Dali::Toolkit::ImageView *result = 0 ;
71740
71741   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71742   if (!arg1) {
71743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71744     return 0;
71745   }
71746   {
71747     try {
71748       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71749     } catch (std::out_of_range& e) {
71750       {
71751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71752       };
71753     } catch (std::exception& e) {
71754       {
71755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71756       };
71757     } catch (Dali::DaliException e) {
71758       {
71759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71760       };
71761     } catch (...) {
71762       {
71763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71764       };
71765     }
71766   }
71767
71768   jresult = (void *)result;
71769   return jresult;
71770 }
71771
71772
71773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
71774   void * jresult ;
71775   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71776   Dali::Toolkit::ImageView *arg2 = 0 ;
71777   Dali::Toolkit::ImageView *result = 0 ;
71778
71779   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71780   arg2 = (Dali::Toolkit::ImageView *)jarg2;
71781   if (!arg2) {
71782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71783     return 0;
71784   }
71785   {
71786     try {
71787       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
71788     } catch (std::out_of_range& e) {
71789       {
71790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71791       };
71792     } catch (std::exception& e) {
71793       {
71794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71795       };
71796     } catch (Dali::DaliException e) {
71797       {
71798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71799       };
71800     } catch (...) {
71801       {
71802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71803       };
71804     }
71805   }
71806
71807   jresult = (void *)result;
71808   return jresult;
71809 }
71810
71811
71812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
71813   void * jresult ;
71814   Dali::BaseHandle arg1 ;
71815   Dali::BaseHandle *argp1 ;
71816   Dali::Toolkit::ImageView result;
71817
71818   argp1 = (Dali::BaseHandle *)jarg1;
71819   if (!argp1) {
71820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71821     return 0;
71822   }
71823   arg1 = *argp1;
71824   {
71825     try {
71826       result = Dali::Toolkit::ImageView::DownCast(arg1);
71827     } catch (std::out_of_range& e) {
71828       {
71829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71830       };
71831     } catch (std::exception& e) {
71832       {
71833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71834       };
71835     } catch (Dali::DaliException e) {
71836       {
71837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71838       };
71839     } catch (...) {
71840       {
71841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71842       };
71843     }
71844   }
71845
71846   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71847   return jresult;
71848 }
71849
71850
71851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
71852   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71853   Dali::Image arg2 ;
71854   Dali::Image *argp2 ;
71855
71856   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71857   argp2 = (Dali::Image *)jarg2;
71858   if (!argp2) {
71859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71860     return ;
71861   }
71862   arg2 = *argp2;
71863   {
71864     try {
71865       (arg1)->SetImage(arg2);
71866     } catch (std::out_of_range& e) {
71867       {
71868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71869       };
71870     } catch (std::exception& e) {
71871       {
71872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71873       };
71874     } catch (Dali::DaliException e) {
71875       {
71876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71877       };
71878     } catch (...) {
71879       {
71880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71881       };
71882     }
71883   }
71884
71885 }
71886
71887
71888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
71889   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71890   std::string *arg2 = 0 ;
71891
71892   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71893   if (!jarg2) {
71894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71895     return ;
71896   }
71897   std::string arg2_str(jarg2);
71898   arg2 = &arg2_str;
71899   {
71900     try {
71901       (arg1)->SetImage((std::string const &)*arg2);
71902     } catch (std::out_of_range& e) {
71903       {
71904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71905       };
71906     } catch (std::exception& e) {
71907       {
71908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71909       };
71910     } catch (Dali::DaliException e) {
71911       {
71912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71913       };
71914     } catch (...) {
71915       {
71916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71917       };
71918     }
71919   }
71920
71921
71922   //argout typemap for const std::string&
71923
71924 }
71925
71926
71927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
71928   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71929   std::string *arg2 = 0 ;
71930   Dali::ImageDimensions arg3 ;
71931   Dali::ImageDimensions *argp3 ;
71932
71933   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71934   if (!jarg2) {
71935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71936     return ;
71937   }
71938   std::string arg2_str(jarg2);
71939   arg2 = &arg2_str;
71940   argp3 = (Dali::ImageDimensions *)jarg3;
71941   if (!argp3) {
71942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71943     return ;
71944   }
71945   arg3 = *argp3;
71946   {
71947     try {
71948       (arg1)->SetImage((std::string const &)*arg2,arg3);
71949     } catch (std::out_of_range& e) {
71950       {
71951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71952       };
71953     } catch (std::exception& e) {
71954       {
71955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71956       };
71957     } catch (Dali::DaliException e) {
71958       {
71959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71960       };
71961     } catch (...) {
71962       {
71963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71964       };
71965     }
71966   }
71967
71968
71969   //argout typemap for const std::string&
71970
71971 }
71972
71973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71974   void * jresult ;
71975   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71976   Dali::Image result;
71977
71978   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71979   {
71980     try {
71981       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71982     } catch (std::out_of_range& e) {
71983       {
71984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71985       };
71986     } catch (std::exception& e) {
71987       {
71988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71989       };
71990     } catch (Dali::DaliException e) {
71991       {
71992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71993       };
71994     } catch (...) {
71995       {
71996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71997       };
71998     }
71999   }
72000
72001   jresult = new Dali::Image((const Dali::Image &)result);
72002   return jresult;
72003 }
72004
72005
72006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72007   int jresult ;
72008   int result;
72009
72010   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72011   jresult = (int)result;
72012   return jresult;
72013 }
72014
72015
72016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72017   int jresult ;
72018   int result;
72019
72020   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72021   jresult = (int)result;
72022   return jresult;
72023 }
72024
72025
72026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72027   int jresult ;
72028   int result;
72029
72030   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72031   jresult = (int)result;
72032   return jresult;
72033 }
72034
72035
72036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72037   int jresult ;
72038   int result;
72039
72040   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72041   jresult = (int)result;
72042   return jresult;
72043 }
72044
72045
72046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72047   int jresult ;
72048   int result;
72049
72050   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72051   jresult = (int)result;
72052   return jresult;
72053 }
72054
72055
72056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72057   int jresult ;
72058   int result;
72059
72060   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72061   jresult = (int)result;
72062   return jresult;
72063 }
72064
72065
72066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72067   int jresult ;
72068   int result;
72069
72070   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72071   jresult = (int)result;
72072   return jresult;
72073 }
72074
72075
72076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72077   int jresult ;
72078   int result;
72079
72080   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72081   jresult = (int)result;
72082   return jresult;
72083 }
72084
72085
72086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72087   void * jresult ;
72088   Dali::Toolkit::Model3dView::Property *result = 0 ;
72089
72090   {
72091     try {
72092       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72093     } catch (std::out_of_range& e) {
72094       {
72095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72096       };
72097     } catch (std::exception& e) {
72098       {
72099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72100       };
72101     } catch (Dali::DaliException e) {
72102       {
72103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72104       };
72105     } catch (...) {
72106       {
72107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72108       };
72109     }
72110   }
72111
72112   jresult = (void *)result;
72113   return jresult;
72114 }
72115
72116
72117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72118   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72119
72120   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72121   {
72122     try {
72123       delete arg1;
72124     } catch (std::out_of_range& e) {
72125       {
72126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72127       };
72128     } catch (std::exception& e) {
72129       {
72130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72131       };
72132     } catch (Dali::DaliException e) {
72133       {
72134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72135       };
72136     } catch (...) {
72137       {
72138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72139       };
72140     }
72141   }
72142
72143 }
72144
72145
72146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72147   void * jresult ;
72148   Dali::Toolkit::Model3dView result;
72149
72150   {
72151     try {
72152       result = Dali::Toolkit::Model3dView::New();
72153     } catch (std::out_of_range& e) {
72154       {
72155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72156       };
72157     } catch (std::exception& e) {
72158       {
72159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72160       };
72161     } catch (Dali::DaliException e) {
72162       {
72163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72164       };
72165     } catch (...) {
72166       {
72167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72168       };
72169     }
72170   }
72171
72172   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72173   return jresult;
72174 }
72175
72176
72177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72178   void * jresult ;
72179   std::string *arg1 = 0 ;
72180   std::string *arg2 = 0 ;
72181   std::string *arg3 = 0 ;
72182   Dali::Toolkit::Model3dView result;
72183
72184   if (!jarg1) {
72185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72186     return 0;
72187   }
72188   std::string arg1_str(jarg1);
72189   arg1 = &arg1_str;
72190   if (!jarg2) {
72191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72192     return 0;
72193   }
72194   std::string arg2_str(jarg2);
72195   arg2 = &arg2_str;
72196   if (!jarg3) {
72197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72198     return 0;
72199   }
72200   std::string arg3_str(jarg3);
72201   arg3 = &arg3_str;
72202   {
72203     try {
72204       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72205     } catch (std::out_of_range& e) {
72206       {
72207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72208       };
72209     } catch (std::exception& e) {
72210       {
72211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72212       };
72213     } catch (Dali::DaliException e) {
72214       {
72215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72216       };
72217     } catch (...) {
72218       {
72219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72220       };
72221     }
72222   }
72223
72224   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72225
72226   //argout typemap for const std::string&
72227
72228
72229   //argout typemap for const std::string&
72230
72231
72232   //argout typemap for const std::string&
72233
72234   return jresult;
72235 }
72236
72237
72238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72239   void * jresult ;
72240   Dali::Toolkit::Model3dView *result = 0 ;
72241
72242   {
72243     try {
72244       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72245     } catch (std::out_of_range& e) {
72246       {
72247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72248       };
72249     } catch (std::exception& e) {
72250       {
72251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72252       };
72253     } catch (Dali::DaliException e) {
72254       {
72255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72256       };
72257     } catch (...) {
72258       {
72259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72260       };
72261     }
72262   }
72263
72264   jresult = (void *)result;
72265   return jresult;
72266 }
72267
72268
72269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72270   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72271
72272   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72273   {
72274     try {
72275       delete arg1;
72276     } catch (std::out_of_range& e) {
72277       {
72278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72279       };
72280     } catch (std::exception& e) {
72281       {
72282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72283       };
72284     } catch (Dali::DaliException e) {
72285       {
72286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72287       };
72288     } catch (...) {
72289       {
72290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72291       };
72292     }
72293   }
72294
72295 }
72296
72297
72298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72299   void * jresult ;
72300   Dali::Toolkit::Model3dView *arg1 = 0 ;
72301   Dali::Toolkit::Model3dView *result = 0 ;
72302
72303   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72304   if (!arg1) {
72305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72306     return 0;
72307   }
72308   {
72309     try {
72310       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72311     } catch (std::out_of_range& e) {
72312       {
72313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72314       };
72315     } catch (std::exception& e) {
72316       {
72317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72318       };
72319     } catch (Dali::DaliException e) {
72320       {
72321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72322       };
72323     } catch (...) {
72324       {
72325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72326       };
72327     }
72328   }
72329
72330   jresult = (void *)result;
72331   return jresult;
72332 }
72333
72334
72335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72336   void * jresult ;
72337   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72338   Dali::Toolkit::Model3dView *arg2 = 0 ;
72339   Dali::Toolkit::Model3dView *result = 0 ;
72340
72341   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72342   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72343   if (!arg2) {
72344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72345     return 0;
72346   }
72347   {
72348     try {
72349       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72350     } catch (std::out_of_range& e) {
72351       {
72352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72353       };
72354     } catch (std::exception& e) {
72355       {
72356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72357       };
72358     } catch (Dali::DaliException e) {
72359       {
72360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72361       };
72362     } catch (...) {
72363       {
72364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72365       };
72366     }
72367   }
72368
72369   jresult = (void *)result;
72370   return jresult;
72371 }
72372
72373
72374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72375   void * jresult ;
72376   Dali::BaseHandle arg1 ;
72377   Dali::BaseHandle *argp1 ;
72378   Dali::Toolkit::Model3dView result;
72379
72380   argp1 = (Dali::BaseHandle *)jarg1;
72381   if (!argp1) {
72382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72383     return 0;
72384   }
72385   arg1 = *argp1;
72386   {
72387     try {
72388       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72389     } catch (std::out_of_range& e) {
72390       {
72391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72392       };
72393     } catch (std::exception& e) {
72394       {
72395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72396       };
72397     } catch (Dali::DaliException e) {
72398       {
72399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72400       };
72401     } catch (...) {
72402       {
72403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72404       };
72405     }
72406   }
72407
72408   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72409   return jresult;
72410 }
72411
72412
72413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72414   int jresult ;
72415   int result;
72416
72417   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72418   jresult = (int)result;
72419   return jresult;
72420 }
72421
72422
72423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72424   int jresult ;
72425   int result;
72426
72427   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72428   jresult = (int)result;
72429   return jresult;
72430 }
72431
72432
72433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72434   int jresult ;
72435   int result;
72436
72437   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72438   jresult = (int)result;
72439   return jresult;
72440 }
72441
72442
72443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72444   int jresult ;
72445   int result;
72446
72447   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72448   jresult = (int)result;
72449   return jresult;
72450 }
72451
72452
72453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72454   int jresult ;
72455   int result;
72456
72457   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72458   jresult = (int)result;
72459   return jresult;
72460 }
72461
72462
72463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72464   int jresult ;
72465   int result;
72466
72467   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72468   jresult = (int)result;
72469   return jresult;
72470 }
72471
72472
72473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72474   int jresult ;
72475   int result;
72476
72477   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72478   jresult = (int)result;
72479   return jresult;
72480 }
72481
72482
72483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72484   int jresult ;
72485   int result;
72486
72487   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72488   jresult = (int)result;
72489   return jresult;
72490 }
72491
72492
72493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72494   int jresult ;
72495   int result;
72496
72497   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72498   jresult = (int)result;
72499   return jresult;
72500 }
72501
72502
72503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72504   void * jresult ;
72505   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72506
72507   {
72508     try {
72509       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72510     } catch (std::out_of_range& e) {
72511       {
72512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72513       };
72514     } catch (std::exception& e) {
72515       {
72516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72517       };
72518     } catch (Dali::DaliException e) {
72519       {
72520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72521       };
72522     } catch (...) {
72523       {
72524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72525       };
72526     }
72527   }
72528
72529   jresult = (void *)result;
72530   return jresult;
72531 }
72532
72533
72534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72535   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72536
72537   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72538   {
72539     try {
72540       delete arg1;
72541     } catch (std::out_of_range& e) {
72542       {
72543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72544       };
72545     } catch (std::exception& e) {
72546       {
72547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72548       };
72549     } catch (Dali::DaliException e) {
72550       {
72551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72552       };
72553     } catch (...) {
72554       {
72555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72556       };
72557     }
72558   }
72559
72560 }
72561
72562
72563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72564   void * jresult ;
72565   Dali::Toolkit::ScrollBar *result = 0 ;
72566
72567   {
72568     try {
72569       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72570     } catch (std::out_of_range& e) {
72571       {
72572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72573       };
72574     } catch (std::exception& e) {
72575       {
72576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72577       };
72578     } catch (Dali::DaliException e) {
72579       {
72580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72581       };
72582     } catch (...) {
72583       {
72584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72585       };
72586     }
72587   }
72588
72589   jresult = (void *)result;
72590   return jresult;
72591 }
72592
72593
72594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72595   void * jresult ;
72596   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72597   Dali::Toolkit::ScrollBar *result = 0 ;
72598
72599   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72600   if (!arg1) {
72601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72602     return 0;
72603   }
72604   {
72605     try {
72606       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72607     } catch (std::out_of_range& e) {
72608       {
72609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72610       };
72611     } catch (std::exception& e) {
72612       {
72613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72614       };
72615     } catch (Dali::DaliException e) {
72616       {
72617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72618       };
72619     } catch (...) {
72620       {
72621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72622       };
72623     }
72624   }
72625
72626   jresult = (void *)result;
72627   return jresult;
72628 }
72629
72630
72631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72632   void * jresult ;
72633   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72634   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72635   Dali::Toolkit::ScrollBar *result = 0 ;
72636
72637   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72638   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72639   if (!arg2) {
72640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72641     return 0;
72642   }
72643   {
72644     try {
72645       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72646     } catch (std::out_of_range& e) {
72647       {
72648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72649       };
72650     } catch (std::exception& e) {
72651       {
72652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72653       };
72654     } catch (Dali::DaliException e) {
72655       {
72656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72657       };
72658     } catch (...) {
72659       {
72660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72661       };
72662     }
72663   }
72664
72665   jresult = (void *)result;
72666   return jresult;
72667 }
72668
72669
72670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72671   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72672
72673   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72674   {
72675     try {
72676       delete arg1;
72677     } catch (std::out_of_range& e) {
72678       {
72679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72680       };
72681     } catch (std::exception& e) {
72682       {
72683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72684       };
72685     } catch (Dali::DaliException e) {
72686       {
72687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72688       };
72689     } catch (...) {
72690       {
72691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72692       };
72693     }
72694   }
72695
72696 }
72697
72698
72699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72700   void * jresult ;
72701   Dali::Toolkit::ScrollBar::Direction arg1 ;
72702   Dali::Toolkit::ScrollBar result;
72703
72704   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72705   {
72706     try {
72707       result = Dali::Toolkit::ScrollBar::New(arg1);
72708     } catch (std::out_of_range& e) {
72709       {
72710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72711       };
72712     } catch (std::exception& e) {
72713       {
72714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72715       };
72716     } catch (Dali::DaliException e) {
72717       {
72718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72719       };
72720     } catch (...) {
72721       {
72722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72723       };
72724     }
72725   }
72726
72727   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72728   return jresult;
72729 }
72730
72731
72732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72733   void * jresult ;
72734   Dali::Toolkit::ScrollBar result;
72735
72736   {
72737     try {
72738       result = Dali::Toolkit::ScrollBar::New();
72739     } catch (std::out_of_range& e) {
72740       {
72741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72742       };
72743     } catch (std::exception& e) {
72744       {
72745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72746       };
72747     } catch (Dali::DaliException e) {
72748       {
72749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72750       };
72751     } catch (...) {
72752       {
72753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72754       };
72755     }
72756   }
72757
72758   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72759   return jresult;
72760 }
72761
72762
72763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72764   void * jresult ;
72765   Dali::BaseHandle arg1 ;
72766   Dali::BaseHandle *argp1 ;
72767   Dali::Toolkit::ScrollBar result;
72768
72769   argp1 = (Dali::BaseHandle *)jarg1;
72770   if (!argp1) {
72771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72772     return 0;
72773   }
72774   arg1 = *argp1;
72775   {
72776     try {
72777       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
72778     } catch (std::out_of_range& e) {
72779       {
72780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72781       };
72782     } catch (std::exception& e) {
72783       {
72784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72785       };
72786     } catch (Dali::DaliException e) {
72787       {
72788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72789       };
72790     } catch (...) {
72791       {
72792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72793       };
72794     }
72795   }
72796
72797   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72798   return jresult;
72799 }
72800
72801
72802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
72803   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72804   Dali::Handle arg2 ;
72805   Dali::Property::Index arg3 ;
72806   Dali::Property::Index arg4 ;
72807   Dali::Property::Index arg5 ;
72808   Dali::Property::Index arg6 ;
72809   Dali::Handle *argp2 ;
72810
72811   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72812   argp2 = (Dali::Handle *)jarg2;
72813   if (!argp2) {
72814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
72815     return ;
72816   }
72817   arg2 = *argp2;
72818   arg3 = (Dali::Property::Index)jarg3;
72819   arg4 = (Dali::Property::Index)jarg4;
72820   arg5 = (Dali::Property::Index)jarg5;
72821   arg6 = (Dali::Property::Index)jarg6;
72822   {
72823     try {
72824       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
72825     } catch (std::out_of_range& e) {
72826       {
72827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72828       };
72829     } catch (std::exception& e) {
72830       {
72831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72832       };
72833     } catch (Dali::DaliException e) {
72834       {
72835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72836       };
72837     } catch (...) {
72838       {
72839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72840       };
72841     }
72842   }
72843
72844 }
72845
72846
72847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
72848   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72849   Dali::Actor arg2 ;
72850   Dali::Actor *argp2 ;
72851
72852   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72853   argp2 = (Dali::Actor *)jarg2;
72854   if (!argp2) {
72855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72856     return ;
72857   }
72858   arg2 = *argp2;
72859   {
72860     try {
72861       (arg1)->SetScrollIndicator(arg2);
72862     } catch (std::out_of_range& e) {
72863       {
72864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72865       };
72866     } catch (std::exception& e) {
72867       {
72868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72869       };
72870     } catch (Dali::DaliException e) {
72871       {
72872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72873       };
72874     } catch (...) {
72875       {
72876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72877       };
72878     }
72879   }
72880
72881 }
72882
72883
72884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
72885   void * jresult ;
72886   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72887   Dali::Actor result;
72888
72889   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72890   {
72891     try {
72892       result = (arg1)->GetScrollIndicator();
72893     } catch (std::out_of_range& e) {
72894       {
72895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72896       };
72897     } catch (std::exception& e) {
72898       {
72899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72900       };
72901     } catch (Dali::DaliException e) {
72902       {
72903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72904       };
72905     } catch (...) {
72906       {
72907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72908       };
72909     }
72910   }
72911
72912   jresult = new Dali::Actor((const Dali::Actor &)result);
72913   return jresult;
72914 }
72915
72916
72917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
72918   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72919   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
72920
72921   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72922   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
72923   if (!arg2) {
72924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
72925     return ;
72926   }
72927   {
72928     try {
72929       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
72930     } catch (std::out_of_range& e) {
72931       {
72932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72933       };
72934     } catch (std::exception& e) {
72935       {
72936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72937       };
72938     } catch (Dali::DaliException e) {
72939       {
72940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72941       };
72942     } catch (...) {
72943       {
72944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72945       };
72946     }
72947   }
72948
72949 }
72950
72951
72952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72953   void * jresult ;
72954   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72955
72956   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72957   {
72958     try {
72959       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()));
72960     } catch (std::out_of_range& e) {
72961       {
72962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72963       };
72964     } catch (std::exception& e) {
72965       {
72966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72967       };
72968     } catch (...) {
72969       {
72970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72971       };
72972     }
72973   }
72974   return jresult;
72975 }
72976
72977
72978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72979   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72980   Dali::Toolkit::ScrollBar::Direction arg2 ;
72981
72982   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72983   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72984   {
72985     try {
72986       (arg1)->SetScrollDirection(arg2);
72987     } catch (std::out_of_range& e) {
72988       {
72989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72990       };
72991     } catch (std::exception& e) {
72992       {
72993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72994       };
72995     } catch (Dali::DaliException e) {
72996       {
72997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72998       };
72999     } catch (...) {
73000       {
73001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73002       };
73003     }
73004   }
73005
73006 }
73007
73008
73009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73010   int jresult ;
73011   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73012   Dali::Toolkit::ScrollBar::Direction result;
73013
73014   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73015   {
73016     try {
73017       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73018     } catch (std::out_of_range& e) {
73019       {
73020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73021       };
73022     } catch (std::exception& e) {
73023       {
73024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73025       };
73026     } catch (Dali::DaliException e) {
73027       {
73028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73029       };
73030     } catch (...) {
73031       {
73032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73033       };
73034     }
73035   }
73036
73037   jresult = (int)result;
73038   return jresult;
73039 }
73040
73041
73042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73043   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73044   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73045
73046   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73047   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73048   {
73049     try {
73050       (arg1)->SetIndicatorHeightPolicy(arg2);
73051     } catch (std::out_of_range& e) {
73052       {
73053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73054       };
73055     } catch (std::exception& e) {
73056       {
73057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73058       };
73059     } catch (Dali::DaliException e) {
73060       {
73061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73062       };
73063     } catch (...) {
73064       {
73065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73066       };
73067     }
73068   }
73069
73070 }
73071
73072
73073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73074   int jresult ;
73075   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73076   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73077
73078   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73079   {
73080     try {
73081       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73082     } catch (std::out_of_range& e) {
73083       {
73084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73085       };
73086     } catch (std::exception& e) {
73087       {
73088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73089       };
73090     } catch (Dali::DaliException e) {
73091       {
73092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73093       };
73094     } catch (...) {
73095       {
73096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73097       };
73098     }
73099   }
73100
73101   jresult = (int)result;
73102   return jresult;
73103 }
73104
73105
73106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73107   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73108   float arg2 ;
73109
73110   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73111   arg2 = (float)jarg2;
73112   {
73113     try {
73114       (arg1)->SetIndicatorFixedHeight(arg2);
73115     } catch (std::out_of_range& e) {
73116       {
73117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73118       };
73119     } catch (std::exception& e) {
73120       {
73121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73122       };
73123     } catch (Dali::DaliException e) {
73124       {
73125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73126       };
73127     } catch (...) {
73128       {
73129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73130       };
73131     }
73132   }
73133
73134 }
73135
73136
73137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73138   float jresult ;
73139   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73140   float result;
73141
73142   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73143   {
73144     try {
73145       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73146     } catch (std::out_of_range& e) {
73147       {
73148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73149       };
73150     } catch (std::exception& e) {
73151       {
73152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73153       };
73154     } catch (Dali::DaliException e) {
73155       {
73156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73157       };
73158     } catch (...) {
73159       {
73160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73161       };
73162     }
73163   }
73164
73165   jresult = result;
73166   return jresult;
73167 }
73168
73169
73170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73171   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73172   float arg2 ;
73173
73174   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73175   arg2 = (float)jarg2;
73176   {
73177     try {
73178       (arg1)->SetIndicatorShowDuration(arg2);
73179     } catch (std::out_of_range& e) {
73180       {
73181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73182       };
73183     } catch (std::exception& e) {
73184       {
73185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73186       };
73187     } catch (Dali::DaliException e) {
73188       {
73189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73190       };
73191     } catch (...) {
73192       {
73193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73194       };
73195     }
73196   }
73197
73198 }
73199
73200
73201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73202   float jresult ;
73203   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73204   float result;
73205
73206   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73207   {
73208     try {
73209       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73210     } catch (std::out_of_range& e) {
73211       {
73212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73213       };
73214     } catch (std::exception& e) {
73215       {
73216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73217       };
73218     } catch (Dali::DaliException e) {
73219       {
73220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73221       };
73222     } catch (...) {
73223       {
73224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73225       };
73226     }
73227   }
73228
73229   jresult = result;
73230   return jresult;
73231 }
73232
73233
73234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73235   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73236   float arg2 ;
73237
73238   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73239   arg2 = (float)jarg2;
73240   {
73241     try {
73242       (arg1)->SetIndicatorHideDuration(arg2);
73243     } catch (std::out_of_range& e) {
73244       {
73245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73246       };
73247     } catch (std::exception& e) {
73248       {
73249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73250       };
73251     } catch (Dali::DaliException e) {
73252       {
73253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73254       };
73255     } catch (...) {
73256       {
73257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73258       };
73259     }
73260   }
73261
73262 }
73263
73264
73265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73266   float jresult ;
73267   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73268   float result;
73269
73270   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73271   {
73272     try {
73273       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73274     } catch (std::out_of_range& e) {
73275       {
73276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73277       };
73278     } catch (std::exception& e) {
73279       {
73280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73281       };
73282     } catch (Dali::DaliException e) {
73283       {
73284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73285       };
73286     } catch (...) {
73287       {
73288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73289       };
73290     }
73291   }
73292
73293   jresult = result;
73294   return jresult;
73295 }
73296
73297
73298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73299   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73300
73301   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73302   {
73303     try {
73304       (arg1)->ShowIndicator();
73305     } catch (std::out_of_range& e) {
73306       {
73307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73308       };
73309     } catch (std::exception& e) {
73310       {
73311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73312       };
73313     } catch (Dali::DaliException e) {
73314       {
73315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73316       };
73317     } catch (...) {
73318       {
73319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73320       };
73321     }
73322   }
73323
73324 }
73325
73326
73327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73328   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73329
73330   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73331   {
73332     try {
73333       (arg1)->HideIndicator();
73334     } catch (std::out_of_range& e) {
73335       {
73336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73337       };
73338     } catch (std::exception& e) {
73339       {
73340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73341       };
73342     } catch (Dali::DaliException e) {
73343       {
73344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73345       };
73346     } catch (...) {
73347       {
73348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73349       };
73350     }
73351   }
73352
73353 }
73354
73355
73356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73357   void * jresult ;
73358   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73359   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73360
73361   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73362   {
73363     try {
73364       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73365     } catch (std::out_of_range& e) {
73366       {
73367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73368       };
73369     } catch (std::exception& e) {
73370       {
73371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73372       };
73373     } catch (Dali::DaliException e) {
73374       {
73375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73376       };
73377     } catch (...) {
73378       {
73379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73380       };
73381     }
73382   }
73383
73384   jresult = (void *)result;
73385   return jresult;
73386 }
73387
73388
73389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73390   void * jresult ;
73391   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73392   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73393
73394   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73395   {
73396     try {
73397       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73398     } catch (std::out_of_range& e) {
73399       {
73400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73401       };
73402     } catch (std::exception& e) {
73403       {
73404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73405       };
73406     } catch (Dali::DaliException e) {
73407       {
73408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73409       };
73410     } catch (...) {
73411       {
73412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73413       };
73414     }
73415   }
73416
73417   jresult = (void *)result;
73418   return jresult;
73419 }
73420
73421
73422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73423   int jresult ;
73424   int result;
73425
73426   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73427   jresult = (int)result;
73428   return jresult;
73429 }
73430
73431
73432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73433   int jresult ;
73434   int result;
73435
73436   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73437   jresult = (int)result;
73438   return jresult;
73439 }
73440
73441
73442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73443   int jresult ;
73444   int result;
73445
73446   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73447   jresult = (int)result;
73448   return jresult;
73449 }
73450
73451
73452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73453   int jresult ;
73454   int result;
73455
73456   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73457   jresult = (int)result;
73458   return jresult;
73459 }
73460
73461
73462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73463   int jresult ;
73464   int result;
73465
73466   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73467   jresult = (int)result;
73468   return jresult;
73469 }
73470
73471
73472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73473   int jresult ;
73474   int result;
73475
73476   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73477   jresult = (int)result;
73478   return jresult;
73479 }
73480
73481
73482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73483   int jresult ;
73484   int result;
73485
73486   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73487   jresult = (int)result;
73488   return jresult;
73489 }
73490
73491
73492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73493   int jresult ;
73494   int result;
73495
73496   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73497   jresult = (int)result;
73498   return jresult;
73499 }
73500
73501
73502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73503   int jresult ;
73504   int result;
73505
73506   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73507   jresult = (int)result;
73508   return jresult;
73509 }
73510
73511
73512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73513   int jresult ;
73514   int result;
73515
73516   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73517   jresult = (int)result;
73518   return jresult;
73519 }
73520
73521
73522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73523   int jresult ;
73524   int result;
73525
73526   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73527   jresult = (int)result;
73528   return jresult;
73529 }
73530
73531
73532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73533   int jresult ;
73534   int result;
73535
73536   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73537   jresult = (int)result;
73538   return jresult;
73539 }
73540
73541
73542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73543   int jresult ;
73544   int result;
73545
73546   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73547   jresult = (int)result;
73548   return jresult;
73549 }
73550
73551
73552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73553   int jresult ;
73554   int result;
73555
73556   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73557   jresult = (int)result;
73558   return jresult;
73559 }
73560
73561
73562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73563   void * jresult ;
73564   Dali::Toolkit::Scrollable::Property *result = 0 ;
73565
73566   {
73567     try {
73568       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73569     } catch (std::out_of_range& e) {
73570       {
73571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73572       };
73573     } catch (std::exception& e) {
73574       {
73575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73576       };
73577     } catch (Dali::DaliException e) {
73578       {
73579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73580       };
73581     } catch (...) {
73582       {
73583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73584       };
73585     }
73586   }
73587
73588   jresult = (void *)result;
73589   return jresult;
73590 }
73591
73592
73593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73594   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73595
73596   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73597   {
73598     try {
73599       delete arg1;
73600     } catch (std::out_of_range& e) {
73601       {
73602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73603       };
73604     } catch (std::exception& e) {
73605       {
73606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73607       };
73608     } catch (Dali::DaliException e) {
73609       {
73610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73611       };
73612     } catch (...) {
73613       {
73614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73615       };
73616     }
73617   }
73618
73619 }
73620
73621
73622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73623   void * jresult ;
73624   Dali::Toolkit::Scrollable *result = 0 ;
73625
73626   {
73627     try {
73628       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73629     } catch (std::out_of_range& e) {
73630       {
73631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73632       };
73633     } catch (std::exception& e) {
73634       {
73635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73636       };
73637     } catch (Dali::DaliException e) {
73638       {
73639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73640       };
73641     } catch (...) {
73642       {
73643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73644       };
73645     }
73646   }
73647
73648   jresult = (void *)result;
73649   return jresult;
73650 }
73651
73652
73653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73654   void * jresult ;
73655   Dali::Toolkit::Scrollable *arg1 = 0 ;
73656   Dali::Toolkit::Scrollable *result = 0 ;
73657
73658   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73659   if (!arg1) {
73660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73661     return 0;
73662   }
73663   {
73664     try {
73665       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73666     } catch (std::out_of_range& e) {
73667       {
73668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73669       };
73670     } catch (std::exception& e) {
73671       {
73672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73673       };
73674     } catch (Dali::DaliException e) {
73675       {
73676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73677       };
73678     } catch (...) {
73679       {
73680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73681       };
73682     }
73683   }
73684
73685   jresult = (void *)result;
73686   return jresult;
73687 }
73688
73689
73690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73691   void * jresult ;
73692   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73693   Dali::Toolkit::Scrollable *arg2 = 0 ;
73694   Dali::Toolkit::Scrollable *result = 0 ;
73695
73696   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73697   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73698   if (!arg2) {
73699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73700     return 0;
73701   }
73702   {
73703     try {
73704       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73705     } catch (std::out_of_range& e) {
73706       {
73707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73708       };
73709     } catch (std::exception& e) {
73710       {
73711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73712       };
73713     } catch (Dali::DaliException e) {
73714       {
73715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73716       };
73717     } catch (...) {
73718       {
73719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73720       };
73721     }
73722   }
73723
73724   jresult = (void *)result;
73725   return jresult;
73726 }
73727
73728
73729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73730   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73731
73732   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73733   {
73734     try {
73735       delete arg1;
73736     } catch (std::out_of_range& e) {
73737       {
73738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73739       };
73740     } catch (std::exception& e) {
73741       {
73742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73743       };
73744     } catch (Dali::DaliException e) {
73745       {
73746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73747       };
73748     } catch (...) {
73749       {
73750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73751       };
73752     }
73753   }
73754
73755 }
73756
73757
73758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73759   void * jresult ;
73760   Dali::BaseHandle arg1 ;
73761   Dali::BaseHandle *argp1 ;
73762   Dali::Toolkit::Scrollable result;
73763
73764   argp1 = (Dali::BaseHandle *)jarg1;
73765   if (!argp1) {
73766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73767     return 0;
73768   }
73769   arg1 = *argp1;
73770   {
73771     try {
73772       result = Dali::Toolkit::Scrollable::DownCast(arg1);
73773     } catch (std::out_of_range& e) {
73774       {
73775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73776       };
73777     } catch (std::exception& e) {
73778       {
73779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73780       };
73781     } catch (Dali::DaliException e) {
73782       {
73783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73784       };
73785     } catch (...) {
73786       {
73787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73788       };
73789     }
73790   }
73791
73792   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
73793   return jresult;
73794 }
73795
73796
73797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
73798   unsigned int jresult ;
73799   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73800   bool result;
73801
73802   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73803   {
73804     try {
73805       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
73806     } catch (std::out_of_range& e) {
73807       {
73808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73809       };
73810     } catch (std::exception& e) {
73811       {
73812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73813       };
73814     } catch (Dali::DaliException e) {
73815       {
73816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73817       };
73818     } catch (...) {
73819       {
73820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73821       };
73822     }
73823   }
73824
73825   jresult = result;
73826   return jresult;
73827 }
73828
73829
73830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
73831   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73832   bool arg2 ;
73833
73834   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73835   arg2 = jarg2 ? true : false;
73836   {
73837     try {
73838       (arg1)->SetOvershootEnabled(arg2);
73839     } catch (std::out_of_range& e) {
73840       {
73841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73842       };
73843     } catch (std::exception& e) {
73844       {
73845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73846       };
73847     } catch (Dali::DaliException e) {
73848       {
73849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73850       };
73851     } catch (...) {
73852       {
73853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73854       };
73855     }
73856   }
73857
73858 }
73859
73860
73861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
73862   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73863   Dali::Vector4 *arg2 = 0 ;
73864
73865   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73866   arg2 = (Dali::Vector4 *)jarg2;
73867   if (!arg2) {
73868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
73869     return ;
73870   }
73871   {
73872     try {
73873       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
73874     } catch (std::out_of_range& e) {
73875       {
73876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73877       };
73878     } catch (std::exception& e) {
73879       {
73880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73881       };
73882     } catch (Dali::DaliException e) {
73883       {
73884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73885       };
73886     } catch (...) {
73887       {
73888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73889       };
73890     }
73891   }
73892
73893 }
73894
73895
73896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
73897   void * jresult ;
73898   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73899   Dali::Vector4 result;
73900
73901   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73902   {
73903     try {
73904       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
73905     } catch (std::out_of_range& e) {
73906       {
73907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73908       };
73909     } catch (std::exception& e) {
73910       {
73911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73912       };
73913     } catch (Dali::DaliException e) {
73914       {
73915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73916       };
73917     } catch (...) {
73918       {
73919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73920       };
73921     }
73922   }
73923
73924   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
73925   return jresult;
73926 }
73927
73928
73929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
73930   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73931   float arg2 ;
73932
73933   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73934   arg2 = (float)jarg2;
73935   {
73936     try {
73937       (arg1)->SetOvershootAnimationSpeed(arg2);
73938     } catch (std::out_of_range& e) {
73939       {
73940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73941       };
73942     } catch (std::exception& e) {
73943       {
73944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73945       };
73946     } catch (Dali::DaliException e) {
73947       {
73948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73949       };
73950     } catch (...) {
73951       {
73952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73953       };
73954     }
73955   }
73956
73957 }
73958
73959
73960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73961   float jresult ;
73962   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73963   float result;
73964
73965   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73966   {
73967     try {
73968       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73969     } catch (std::out_of_range& e) {
73970       {
73971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73972       };
73973     } catch (std::exception& e) {
73974       {
73975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73976       };
73977     } catch (Dali::DaliException e) {
73978       {
73979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73980       };
73981     } catch (...) {
73982       {
73983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73984       };
73985     }
73986   }
73987
73988   jresult = result;
73989   return jresult;
73990 }
73991
73992
73993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73994   void * jresult ;
73995   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73996   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73997
73998   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73999   {
74000     try {
74001       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74002     } catch (std::out_of_range& e) {
74003       {
74004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74005       };
74006     } catch (std::exception& e) {
74007       {
74008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74009       };
74010     } catch (Dali::DaliException e) {
74011       {
74012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74013       };
74014     } catch (...) {
74015       {
74016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74017       };
74018     }
74019   }
74020
74021   jresult = (void *)result;
74022   return jresult;
74023 }
74024
74025
74026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74027   void * jresult ;
74028   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74029   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74030
74031   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74032   {
74033     try {
74034       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74035     } catch (std::out_of_range& e) {
74036       {
74037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74038       };
74039     } catch (std::exception& e) {
74040       {
74041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74042       };
74043     } catch (Dali::DaliException e) {
74044       {
74045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74046       };
74047     } catch (...) {
74048       {
74049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74050       };
74051     }
74052   }
74053
74054   jresult = (void *)result;
74055   return jresult;
74056 }
74057
74058
74059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74060   void * jresult ;
74061   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74062   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74063
74064   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74065   {
74066     try {
74067       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74068     } catch (std::out_of_range& e) {
74069       {
74070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74071       };
74072     } catch (std::exception& e) {
74073       {
74074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74075       };
74076     } catch (Dali::DaliException e) {
74077       {
74078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74079       };
74080     } catch (...) {
74081       {
74082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74083       };
74084     }
74085   }
74086
74087   jresult = (void *)result;
74088   return jresult;
74089 }
74090
74091
74092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74093   unsigned int jresult ;
74094   Dali::Toolkit::ControlOrientation::Type arg1 ;
74095   bool result;
74096
74097   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74098   {
74099     try {
74100       result = (bool)Dali::Toolkit::IsVertical(arg1);
74101     } catch (std::out_of_range& e) {
74102       {
74103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74104       };
74105     } catch (std::exception& e) {
74106       {
74107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74108       };
74109     } catch (Dali::DaliException e) {
74110       {
74111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74112       };
74113     } catch (...) {
74114       {
74115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74116       };
74117     }
74118   }
74119
74120   jresult = result;
74121   return jresult;
74122 }
74123
74124
74125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74126   unsigned int jresult ;
74127   Dali::Toolkit::ControlOrientation::Type arg1 ;
74128   bool result;
74129
74130   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74131   {
74132     try {
74133       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74134     } catch (std::out_of_range& e) {
74135       {
74136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74137       };
74138     } catch (std::exception& e) {
74139       {
74140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74141       };
74142     } catch (Dali::DaliException e) {
74143       {
74144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74145       };
74146     } catch (...) {
74147       {
74148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74149       };
74150     }
74151   }
74152
74153   jresult = result;
74154   return jresult;
74155 }
74156
74157
74158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74159   void * jresult ;
74160   unsigned int arg1 ;
74161   unsigned int arg2 ;
74162   Dali::Toolkit::ItemRange *result = 0 ;
74163
74164   arg1 = (unsigned int)jarg1;
74165   arg2 = (unsigned int)jarg2;
74166   {
74167     try {
74168       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74169     } catch (std::out_of_range& e) {
74170       {
74171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74172       };
74173     } catch (std::exception& e) {
74174       {
74175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74176       };
74177     } catch (Dali::DaliException e) {
74178       {
74179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74180       };
74181     } catch (...) {
74182       {
74183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74184       };
74185     }
74186   }
74187
74188   jresult = (void *)result;
74189   return jresult;
74190 }
74191
74192
74193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74194   void * jresult ;
74195   Dali::Toolkit::ItemRange *arg1 = 0 ;
74196   Dali::Toolkit::ItemRange *result = 0 ;
74197
74198   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74199   if (!arg1) {
74200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74201     return 0;
74202   }
74203   {
74204     try {
74205       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74206     } catch (std::out_of_range& e) {
74207       {
74208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74209       };
74210     } catch (std::exception& e) {
74211       {
74212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74213       };
74214     } catch (Dali::DaliException e) {
74215       {
74216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74217       };
74218     } catch (...) {
74219       {
74220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74221       };
74222     }
74223   }
74224
74225   jresult = (void *)result;
74226   return jresult;
74227 }
74228
74229
74230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74231   void * jresult ;
74232   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74233   Dali::Toolkit::ItemRange *arg2 = 0 ;
74234   Dali::Toolkit::ItemRange *result = 0 ;
74235
74236   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74237   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74238   if (!arg2) {
74239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74240     return 0;
74241   }
74242   {
74243     try {
74244       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74245     } catch (std::out_of_range& e) {
74246       {
74247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74248       };
74249     } catch (std::exception& e) {
74250       {
74251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74252       };
74253     } catch (Dali::DaliException e) {
74254       {
74255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74256       };
74257     } catch (...) {
74258       {
74259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74260       };
74261     }
74262   }
74263
74264   jresult = (void *)result;
74265   return jresult;
74266 }
74267
74268
74269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74270   unsigned int jresult ;
74271   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74272   unsigned int arg2 ;
74273   bool result;
74274
74275   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74276   arg2 = (unsigned int)jarg2;
74277   {
74278     try {
74279       result = (bool)(arg1)->Within(arg2);
74280     } catch (std::out_of_range& e) {
74281       {
74282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74283       };
74284     } catch (std::exception& e) {
74285       {
74286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74287       };
74288     } catch (Dali::DaliException e) {
74289       {
74290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74291       };
74292     } catch (...) {
74293       {
74294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74295       };
74296     }
74297   }
74298
74299   jresult = result;
74300   return jresult;
74301 }
74302
74303
74304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74305   void * jresult ;
74306   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74307   Dali::Toolkit::ItemRange *arg2 = 0 ;
74308   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74309
74310   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74311   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74312   if (!arg2) {
74313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74314     return 0;
74315   }
74316   {
74317     try {
74318       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74319     } catch (std::out_of_range& e) {
74320       {
74321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74322       };
74323     } catch (std::exception& e) {
74324       {
74325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74326       };
74327     } catch (Dali::DaliException e) {
74328       {
74329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74330       };
74331     } catch (...) {
74332       {
74333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74334       };
74335     }
74336   }
74337
74338   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74339   return jresult;
74340 }
74341
74342
74343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74344   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74345   unsigned int arg2 ;
74346
74347   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74348   arg2 = (unsigned int)jarg2;
74349   if (arg1) (arg1)->begin = arg2;
74350 }
74351
74352
74353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74354   unsigned int jresult ;
74355   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74356   unsigned int result;
74357
74358   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74359   result = (unsigned int) ((arg1)->begin);
74360   jresult = result;
74361   return jresult;
74362 }
74363
74364
74365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74366   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74367   unsigned int arg2 ;
74368
74369   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74370   arg2 = (unsigned int)jarg2;
74371   if (arg1) (arg1)->end = arg2;
74372 }
74373
74374
74375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74376   unsigned int jresult ;
74377   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74378   unsigned int result;
74379
74380   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74381   result = (unsigned int) ((arg1)->end);
74382   jresult = result;
74383   return jresult;
74384 }
74385
74386
74387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74388   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74389
74390   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74391   {
74392     try {
74393       delete arg1;
74394     } catch (std::out_of_range& e) {
74395       {
74396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74397       };
74398     } catch (std::exception& e) {
74399       {
74400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74401       };
74402     } catch (Dali::DaliException e) {
74403       {
74404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74405       };
74406     } catch (...) {
74407       {
74408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74409       };
74410     }
74411   }
74412
74413 }
74414
74415
74416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74417   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74418
74419   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74420   {
74421     try {
74422       delete arg1;
74423     } catch (std::out_of_range& e) {
74424       {
74425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74426       };
74427     } catch (std::exception& e) {
74428       {
74429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74430       };
74431     } catch (Dali::DaliException e) {
74432       {
74433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74434       };
74435     } catch (...) {
74436       {
74437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74438       };
74439     }
74440   }
74441
74442 }
74443
74444
74445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74446   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74447   Dali::Toolkit::ControlOrientation::Type arg2 ;
74448
74449   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74450   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74451   {
74452     try {
74453       (arg1)->SetOrientation(arg2);
74454     } catch (std::out_of_range& e) {
74455       {
74456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74457       };
74458     } catch (std::exception& e) {
74459       {
74460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74461       };
74462     } catch (Dali::DaliException e) {
74463       {
74464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74465       };
74466     } catch (...) {
74467       {
74468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74469       };
74470     }
74471   }
74472
74473 }
74474
74475
74476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74477   int jresult ;
74478   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74479   Dali::Toolkit::ControlOrientation::Type result;
74480
74481   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74482   {
74483     try {
74484       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
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 = (int)result;
74505   return jresult;
74506 }
74507
74508
74509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74510   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74511   Dali::Property::Map *arg2 = 0 ;
74512
74513   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74514   arg2 = (Dali::Property::Map *)jarg2;
74515   if (!arg2) {
74516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74517     return ;
74518   }
74519   {
74520     try {
74521       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74522     } catch (std::out_of_range& e) {
74523       {
74524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74525       };
74526     } catch (std::exception& e) {
74527       {
74528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74529       };
74530     } catch (Dali::DaliException e) {
74531       {
74532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74533       };
74534     } catch (...) {
74535       {
74536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74537       };
74538     }
74539   }
74540
74541 }
74542
74543
74544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74545   void * jresult ;
74546   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74547   Dali::Property::Map result;
74548
74549   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74550   {
74551     try {
74552       result = (arg1)->GetLayoutProperties();
74553     } catch (std::out_of_range& e) {
74554       {
74555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74556       };
74557     } catch (std::exception& e) {
74558       {
74559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74560       };
74561     } catch (Dali::DaliException e) {
74562       {
74563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74564       };
74565     } catch (...) {
74566       {
74567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74568       };
74569     }
74570   }
74571
74572   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74573   return jresult;
74574 }
74575
74576
74577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74578   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74579   unsigned int arg2 ;
74580   Dali::Vector3 *arg3 = 0 ;
74581   Dali::Vector3 *arg4 = 0 ;
74582
74583   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74584   arg2 = (unsigned int)jarg2;
74585   arg3 = (Dali::Vector3 *)jarg3;
74586   if (!arg3) {
74587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74588     return ;
74589   }
74590   arg4 = (Dali::Vector3 *)jarg4;
74591   if (!arg4) {
74592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74593     return ;
74594   }
74595   {
74596     try {
74597       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74598     } catch (std::out_of_range& e) {
74599       {
74600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74601       };
74602     } catch (std::exception& e) {
74603       {
74604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74605       };
74606     } catch (Dali::DaliException e) {
74607       {
74608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74609       };
74610     } catch (...) {
74611       {
74612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74613       };
74614     }
74615   }
74616
74617 }
74618
74619
74620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74621   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74622   Dali::Vector3 *arg2 = 0 ;
74623
74624   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74625   arg2 = (Dali::Vector3 *)jarg2;
74626   if (!arg2) {
74627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74628     return ;
74629   }
74630   {
74631     try {
74632       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74633     } catch (std::out_of_range& e) {
74634       {
74635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74636       };
74637     } catch (std::exception& e) {
74638       {
74639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74640       };
74641     } catch (Dali::DaliException e) {
74642       {
74643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74644       };
74645     } catch (...) {
74646       {
74647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74648       };
74649     }
74650   }
74651
74652 }
74653
74654
74655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74656   float jresult ;
74657   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74658   unsigned int arg2 ;
74659   Dali::Vector3 arg3 ;
74660   Dali::Vector3 *argp3 ;
74661   float result;
74662
74663   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74664   arg2 = (unsigned int)jarg2;
74665   argp3 = (Dali::Vector3 *)jarg3;
74666   if (!argp3) {
74667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74668     return 0;
74669   }
74670   arg3 = *argp3;
74671   {
74672     try {
74673       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74674     } catch (std::out_of_range& e) {
74675       {
74676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74677       };
74678     } catch (std::exception& e) {
74679       {
74680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74681       };
74682     } catch (Dali::DaliException e) {
74683       {
74684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74685       };
74686     } catch (...) {
74687       {
74688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74689       };
74690     }
74691   }
74692
74693   jresult = result;
74694   return jresult;
74695 }
74696
74697
74698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74699   float jresult ;
74700   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74701   float arg2 ;
74702   float result;
74703
74704   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74705   arg2 = (float)jarg2;
74706   {
74707     try {
74708       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74709     } catch (std::out_of_range& e) {
74710       {
74711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74712       };
74713     } catch (std::exception& e) {
74714       {
74715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74716       };
74717     } catch (Dali::DaliException e) {
74718       {
74719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74720       };
74721     } catch (...) {
74722       {
74723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74724       };
74725     }
74726   }
74727
74728   jresult = result;
74729   return jresult;
74730 }
74731
74732
74733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74734   float jresult ;
74735   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74736   unsigned int arg2 ;
74737   float result;
74738
74739   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74740   arg2 = (unsigned int)jarg2;
74741   {
74742     try {
74743       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
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 = result;
74764   return jresult;
74765 }
74766
74767
74768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
74769   void * jresult ;
74770   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74771   float arg2 ;
74772   Dali::Vector3 arg3 ;
74773   Dali::Vector3 *argp3 ;
74774   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74775
74776   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74777   arg2 = (float)jarg2;
74778   argp3 = (Dali::Vector3 *)jarg3;
74779   if (!argp3) {
74780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74781     return 0;
74782   }
74783   arg3 = *argp3;
74784   {
74785     try {
74786       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
74787     } catch (std::out_of_range& e) {
74788       {
74789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74790       };
74791     } catch (std::exception& e) {
74792       {
74793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74794       };
74795     } catch (Dali::DaliException e) {
74796       {
74797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74798       };
74799     } catch (...) {
74800       {
74801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74802       };
74803     }
74804   }
74805
74806   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74807   return jresult;
74808 }
74809
74810
74811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74812   float jresult ;
74813   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74814   int arg2 ;
74815   float arg3 ;
74816   Dali::Vector3 *arg4 = 0 ;
74817   float result;
74818
74819   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74820   arg2 = (int)jarg2;
74821   arg3 = (float)jarg3;
74822   arg4 = (Dali::Vector3 *)jarg4;
74823   if (!arg4) {
74824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74825     return 0;
74826   }
74827   {
74828     try {
74829       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74830     } catch (std::out_of_range& e) {
74831       {
74832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74833       };
74834     } catch (std::exception& e) {
74835       {
74836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74837       };
74838     } catch (Dali::DaliException e) {
74839       {
74840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74841       };
74842     } catch (...) {
74843       {
74844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74845       };
74846     }
74847   }
74848
74849   jresult = result;
74850   return jresult;
74851 }
74852
74853
74854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
74855   unsigned int jresult ;
74856   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74857   Dali::Vector3 arg2 ;
74858   Dali::Vector3 *argp2 ;
74859   unsigned int result;
74860
74861   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74862   argp2 = (Dali::Vector3 *)jarg2;
74863   if (!argp2) {
74864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74865     return 0;
74866   }
74867   arg2 = *argp2;
74868   {
74869     try {
74870       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
74871     } catch (std::out_of_range& e) {
74872       {
74873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74874       };
74875     } catch (std::exception& e) {
74876       {
74877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74878       };
74879     } catch (Dali::DaliException e) {
74880       {
74881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74882       };
74883     } catch (...) {
74884       {
74885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74886       };
74887     }
74888   }
74889
74890   jresult = result;
74891   return jresult;
74892 }
74893
74894
74895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74896   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74897   unsigned int arg2 ;
74898   Dali::Vector3 *arg3 = 0 ;
74899   Dali::Vector3 *arg4 = 0 ;
74900
74901   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74902   arg2 = (unsigned int)jarg2;
74903   arg3 = (Dali::Vector3 *)jarg3;
74904   if (!arg3) {
74905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74906     return ;
74907   }
74908   arg4 = (Dali::Vector3 *)jarg4;
74909   if (!arg4) {
74910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74911     return ;
74912   }
74913   {
74914     try {
74915       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74916     } catch (std::out_of_range& e) {
74917       {
74918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74919       };
74920     } catch (std::exception& e) {
74921       {
74922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74923       };
74924     } catch (Dali::DaliException e) {
74925       {
74926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74927       };
74928     } catch (...) {
74929       {
74930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74931       };
74932     }
74933   }
74934
74935 }
74936
74937
74938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74939   void * jresult ;
74940   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74941   Dali::Degree result;
74942
74943   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74944   {
74945     try {
74946       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74947     } catch (std::out_of_range& e) {
74948       {
74949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74950       };
74951     } catch (std::exception& e) {
74952       {
74953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74954       };
74955     } catch (Dali::DaliException e) {
74956       {
74957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74958       };
74959     } catch (...) {
74960       {
74961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74962       };
74963     }
74964   }
74965
74966   jresult = new Dali::Degree((const Dali::Degree &)result);
74967   return jresult;
74968 }
74969
74970
74971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74972   float jresult ;
74973   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74974   float result;
74975
74976   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74977   {
74978     try {
74979       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74980     } catch (std::out_of_range& e) {
74981       {
74982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74983       };
74984     } catch (std::exception& e) {
74985       {
74986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74987       };
74988     } catch (Dali::DaliException e) {
74989       {
74990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74991       };
74992     } catch (...) {
74993       {
74994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74995       };
74996     }
74997   }
74998
74999   jresult = result;
75000   return jresult;
75001 }
75002
75003
75004 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75005   float jresult ;
75006   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75007   float result;
75008
75009   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75010   {
75011     try {
75012       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75013     } catch (std::out_of_range& e) {
75014       {
75015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75016       };
75017     } catch (std::exception& e) {
75018       {
75019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75020       };
75021     } catch (Dali::DaliException e) {
75022       {
75023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75024       };
75025     } catch (...) {
75026       {
75027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75028       };
75029     }
75030   }
75031
75032   jresult = result;
75033   return jresult;
75034 }
75035
75036
75037 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75038   float jresult ;
75039   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75040   float result;
75041
75042   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75043   {
75044     try {
75045       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75046     } catch (std::out_of_range& e) {
75047       {
75048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75049       };
75050     } catch (std::exception& e) {
75051       {
75052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75053       };
75054     } catch (Dali::DaliException e) {
75055       {
75056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75057       };
75058     } catch (...) {
75059       {
75060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75061       };
75062     }
75063   }
75064
75065   jresult = result;
75066   return jresult;
75067 }
75068
75069
75070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75071   int jresult ;
75072   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75073   int arg2 ;
75074   int arg3 ;
75075   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75076   bool arg5 ;
75077   int result;
75078
75079   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75080   arg2 = (int)jarg2;
75081   arg3 = (int)jarg3;
75082   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75083   arg5 = jarg5 ? true : false;
75084   {
75085     try {
75086       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75087     } catch (std::out_of_range& e) {
75088       {
75089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75090       };
75091     } catch (std::exception& e) {
75092       {
75093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75094       };
75095     } catch (Dali::DaliException e) {
75096       {
75097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75098       };
75099     } catch (...) {
75100       {
75101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75102       };
75103     }
75104   }
75105
75106   jresult = result;
75107   return jresult;
75108 }
75109
75110
75111 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75112   float jresult ;
75113   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75114   float result;
75115
75116   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75117   {
75118     try {
75119       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75120     } catch (std::out_of_range& e) {
75121       {
75122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75123       };
75124     } catch (std::exception& e) {
75125       {
75126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75127       };
75128     } catch (Dali::DaliException e) {
75129       {
75130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75131       };
75132     } catch (...) {
75133       {
75134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75135       };
75136     }
75137   }
75138
75139   jresult = result;
75140   return jresult;
75141 }
75142
75143
75144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75145   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75146   Dali::Actor *arg2 = 0 ;
75147   int arg3 ;
75148   Dali::Vector3 *arg4 = 0 ;
75149   Dali::Actor *arg5 = 0 ;
75150
75151   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75152   arg2 = (Dali::Actor *)jarg2;
75153   if (!arg2) {
75154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75155     return ;
75156   }
75157   arg3 = (int)jarg3;
75158   arg4 = (Dali::Vector3 *)jarg4;
75159   if (!arg4) {
75160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75161     return ;
75162   }
75163   arg5 = (Dali::Actor *)jarg5;
75164   if (!arg5) {
75165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75166     return ;
75167   }
75168   {
75169     try {
75170       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75171     } catch (std::out_of_range& e) {
75172       {
75173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75174       };
75175     } catch (std::exception& e) {
75176       {
75177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75178       };
75179     } catch (Dali::DaliException e) {
75180       {
75181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75182       };
75183     } catch (...) {
75184       {
75185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75186       };
75187     }
75188   }
75189
75190 }
75191
75192
75193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75194   void * jresult ;
75195   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75196   int arg2 ;
75197   float arg3 ;
75198   Dali::Vector3 *arg4 = 0 ;
75199   Dali::Vector3 result;
75200
75201   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75202   arg2 = (int)jarg2;
75203   arg3 = (float)jarg3;
75204   arg4 = (Dali::Vector3 *)jarg4;
75205   if (!arg4) {
75206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75207     return 0;
75208   }
75209   {
75210     try {
75211       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75212     } catch (std::out_of_range& e) {
75213       {
75214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75215       };
75216     } catch (std::exception& e) {
75217       {
75218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75219       };
75220     } catch (Dali::DaliException e) {
75221       {
75222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75223       };
75224     } catch (...) {
75225       {
75226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75227       };
75228     }
75229   }
75230
75231   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75232   return jresult;
75233 }
75234
75235
75236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75237   void * jresult ;
75238   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75239   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75240
75241   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75242   {
75243     try {
75244       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75245     } catch (std::out_of_range& e) {
75246       {
75247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75248       };
75249     } catch (std::exception& e) {
75250       {
75251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75252       };
75253     } catch (Dali::DaliException e) {
75254       {
75255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75256       };
75257     } catch (...) {
75258       {
75259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75260       };
75261     }
75262   }
75263
75264   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75265   return jresult;
75266 }
75267
75268
75269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75270   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75271
75272   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75273   {
75274     try {
75275       delete arg1;
75276     } catch (std::out_of_range& e) {
75277       {
75278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75279       };
75280     } catch (std::exception& e) {
75281       {
75282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75283       };
75284     } catch (Dali::DaliException e) {
75285       {
75286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75287       };
75288     } catch (...) {
75289       {
75290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75291       };
75292     }
75293   }
75294
75295 }
75296
75297
75298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75299   unsigned int jresult ;
75300   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75301   unsigned int result;
75302
75303   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75304   {
75305     try {
75306       result = (unsigned int)(arg1)->GetNumberOfItems();
75307     } catch (std::out_of_range& e) {
75308       {
75309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75310       };
75311     } catch (std::exception& e) {
75312       {
75313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75314       };
75315     } catch (Dali::DaliException e) {
75316       {
75317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75318       };
75319     } catch (...) {
75320       {
75321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75322       };
75323     }
75324   }
75325
75326   jresult = result;
75327   return jresult;
75328 }
75329
75330
75331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75332   void * jresult ;
75333   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75334   unsigned int arg2 ;
75335   Dali::Actor result;
75336
75337   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75338   arg2 = (unsigned int)jarg2;
75339   {
75340     try {
75341       result = (arg1)->NewItem(arg2);
75342     } catch (std::out_of_range& e) {
75343       {
75344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75345       };
75346     } catch (std::exception& e) {
75347       {
75348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75349       };
75350     } catch (Dali::DaliException e) {
75351       {
75352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75353       };
75354     } catch (...) {
75355       {
75356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75357       };
75358     }
75359   }
75360
75361   jresult = new Dali::Actor((const Dali::Actor &)result);
75362   return jresult;
75363 }
75364
75365
75366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75367   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75368   unsigned int arg2 ;
75369   Dali::Actor arg3 ;
75370   Dali::Actor *argp3 ;
75371
75372   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75373   arg2 = (unsigned int)jarg2;
75374   argp3 = (Dali::Actor *)jarg3;
75375   if (!argp3) {
75376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75377     return ;
75378   }
75379   arg3 = *argp3;
75380   {
75381     try {
75382       (arg1)->ItemReleased(arg2,arg3);
75383     } catch (std::out_of_range& e) {
75384       {
75385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75386       };
75387     } catch (std::exception& e) {
75388       {
75389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75390       };
75391     } catch (Dali::DaliException e) {
75392       {
75393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75394       };
75395     } catch (...) {
75396       {
75397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75398       };
75399     }
75400   }
75401
75402 }
75403
75404
75405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75406   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75407   unsigned int arg2 ;
75408   Dali::Actor arg3 ;
75409   Dali::Actor *argp3 ;
75410
75411   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75412   arg2 = (unsigned int)jarg2;
75413   argp3 = (Dali::Actor *)jarg3;
75414   if (!argp3) {
75415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75416     return ;
75417   }
75418   arg3 = *argp3;
75419   {
75420     try {
75421       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75422     } catch (std::out_of_range& e) {
75423       {
75424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75425       };
75426     } catch (std::exception& e) {
75427       {
75428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75429       };
75430     } catch (Dali::DaliException e) {
75431       {
75432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75433       };
75434     } catch (...) {
75435       {
75436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75437       };
75438     }
75439   }
75440
75441 }
75442
75443
75444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75445   void * jresult ;
75446   Dali::Toolkit::ItemFactory *result = 0 ;
75447
75448   {
75449     try {
75450       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75451     } catch (std::out_of_range& e) {
75452       {
75453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75454       };
75455     } catch (std::exception& e) {
75456       {
75457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75458       };
75459     } catch (Dali::DaliException e) {
75460       {
75461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75462       };
75463     } catch (...) {
75464       {
75465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75466       };
75467     }
75468   }
75469
75470   jresult = (void *)result;
75471   return jresult;
75472 }
75473
75474
75475 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) {
75476   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75477   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75478   if (director) {
75479     director->swig_connect_director(callback0, callback1, callback2);
75480   }
75481 }
75482
75483
75484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75485   int jresult ;
75486   int result;
75487
75488   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75489   jresult = (int)result;
75490   return jresult;
75491 }
75492
75493
75494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75495   int jresult ;
75496   int result;
75497
75498   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75499   jresult = (int)result;
75500   return jresult;
75501 }
75502
75503
75504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75505   int jresult ;
75506   int result;
75507
75508   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75509   jresult = (int)result;
75510   return jresult;
75511 }
75512
75513
75514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75515   int jresult ;
75516   int result;
75517
75518   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75519   jresult = (int)result;
75520   return jresult;
75521 }
75522
75523
75524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75525   int jresult ;
75526   int result;
75527
75528   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75529   jresult = (int)result;
75530   return jresult;
75531 }
75532
75533
75534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75535   int jresult ;
75536   int result;
75537
75538   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75539   jresult = (int)result;
75540   return jresult;
75541 }
75542
75543
75544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75545   int jresult ;
75546   int result;
75547
75548   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75549   jresult = (int)result;
75550   return jresult;
75551 }
75552
75553
75554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75555   int jresult ;
75556   int result;
75557
75558   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75559   jresult = (int)result;
75560   return jresult;
75561 }
75562
75563
75564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75565   int jresult ;
75566   int result;
75567
75568   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75569   jresult = (int)result;
75570   return jresult;
75571 }
75572
75573
75574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75575   int jresult ;
75576   int result;
75577
75578   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75579   jresult = (int)result;
75580   return jresult;
75581 }
75582
75583
75584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75585   int jresult ;
75586   int result;
75587
75588   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75589   jresult = (int)result;
75590   return jresult;
75591 }
75592
75593
75594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75595   void * jresult ;
75596   Dali::Toolkit::ItemView::Property *result = 0 ;
75597
75598   {
75599     try {
75600       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75601     } catch (std::out_of_range& e) {
75602       {
75603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75604       };
75605     } catch (std::exception& e) {
75606       {
75607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75608       };
75609     } catch (Dali::DaliException e) {
75610       {
75611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75612       };
75613     } catch (...) {
75614       {
75615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75616       };
75617     }
75618   }
75619
75620   jresult = (void *)result;
75621   return jresult;
75622 }
75623
75624
75625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75626   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75627
75628   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75629   {
75630     try {
75631       delete arg1;
75632     } catch (std::out_of_range& e) {
75633       {
75634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75635       };
75636     } catch (std::exception& e) {
75637       {
75638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75639       };
75640     } catch (Dali::DaliException e) {
75641       {
75642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75643       };
75644     } catch (...) {
75645       {
75646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75647       };
75648     }
75649   }
75650
75651 }
75652
75653
75654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75655   void * jresult ;
75656   Dali::Toolkit::ItemView *result = 0 ;
75657
75658   {
75659     try {
75660       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75661     } catch (std::out_of_range& e) {
75662       {
75663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75664       };
75665     } catch (std::exception& e) {
75666       {
75667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75668       };
75669     } catch (Dali::DaliException e) {
75670       {
75671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75672       };
75673     } catch (...) {
75674       {
75675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75676       };
75677     }
75678   }
75679
75680   jresult = (void *)result;
75681   return jresult;
75682 }
75683
75684
75685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75686   void * jresult ;
75687   Dali::Toolkit::ItemView *arg1 = 0 ;
75688   Dali::Toolkit::ItemView *result = 0 ;
75689
75690   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75691   if (!arg1) {
75692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75693     return 0;
75694   }
75695   {
75696     try {
75697       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75698     } catch (std::out_of_range& e) {
75699       {
75700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75701       };
75702     } catch (std::exception& e) {
75703       {
75704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75705       };
75706     } catch (Dali::DaliException e) {
75707       {
75708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75709       };
75710     } catch (...) {
75711       {
75712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75713       };
75714     }
75715   }
75716
75717   jresult = (void *)result;
75718   return jresult;
75719 }
75720
75721
75722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75723   void * jresult ;
75724   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75725   Dali::Toolkit::ItemView *arg2 = 0 ;
75726   Dali::Toolkit::ItemView *result = 0 ;
75727
75728   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75729   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75730   if (!arg2) {
75731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75732     return 0;
75733   }
75734   {
75735     try {
75736       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75737     } catch (std::out_of_range& e) {
75738       {
75739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75740       };
75741     } catch (std::exception& e) {
75742       {
75743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75744       };
75745     } catch (Dali::DaliException e) {
75746       {
75747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75748       };
75749     } catch (...) {
75750       {
75751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75752       };
75753     }
75754   }
75755
75756   jresult = (void *)result;
75757   return jresult;
75758 }
75759
75760
75761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75762   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75763
75764   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75765   {
75766     try {
75767       delete arg1;
75768     } catch (std::out_of_range& e) {
75769       {
75770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75771       };
75772     } catch (std::exception& e) {
75773       {
75774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75775       };
75776     } catch (Dali::DaliException e) {
75777       {
75778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75779       };
75780     } catch (...) {
75781       {
75782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75783       };
75784     }
75785   }
75786
75787 }
75788
75789
75790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
75791   void * jresult ;
75792   Dali::Toolkit::ItemFactory *arg1 = 0 ;
75793   Dali::Toolkit::ItemView result;
75794
75795   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75796   if (!arg1) {
75797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
75798     return 0;
75799   }
75800   {
75801     try {
75802       result = Dali::Toolkit::ItemView::New(*arg1);
75803     } catch (std::out_of_range& e) {
75804       {
75805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75806       };
75807     } catch (std::exception& e) {
75808       {
75809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75810       };
75811     } catch (Dali::DaliException e) {
75812       {
75813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75814       };
75815     } catch (...) {
75816       {
75817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75818       };
75819     }
75820   }
75821
75822   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75823   return jresult;
75824 }
75825
75826
75827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
75828   void * jresult ;
75829   Dali::BaseHandle arg1 ;
75830   Dali::BaseHandle *argp1 ;
75831   Dali::Toolkit::ItemView result;
75832
75833   argp1 = (Dali::BaseHandle *)jarg1;
75834   if (!argp1) {
75835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75836     return 0;
75837   }
75838   arg1 = *argp1;
75839   {
75840     try {
75841       result = Dali::Toolkit::ItemView::DownCast(arg1);
75842     } catch (std::out_of_range& e) {
75843       {
75844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75845       };
75846     } catch (std::exception& e) {
75847       {
75848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75849       };
75850     } catch (Dali::DaliException e) {
75851       {
75852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75853       };
75854     } catch (...) {
75855       {
75856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75857       };
75858     }
75859   }
75860
75861   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75862   return jresult;
75863 }
75864
75865
75866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
75867   unsigned int jresult ;
75868   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75869   unsigned int result;
75870
75871   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75872   {
75873     try {
75874       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
75875     } catch (std::out_of_range& e) {
75876       {
75877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75878       };
75879     } catch (std::exception& e) {
75880       {
75881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75882       };
75883     } catch (Dali::DaliException e) {
75884       {
75885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75886       };
75887     } catch (...) {
75888       {
75889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75890       };
75891     }
75892   }
75893
75894   jresult = result;
75895   return jresult;
75896 }
75897
75898
75899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
75900   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75901   Dali::Toolkit::ItemLayout *arg2 = 0 ;
75902
75903   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75904   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
75905   if (!arg2) {
75906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
75907     return ;
75908   }
75909   {
75910     try {
75911       (arg1)->AddLayout(*arg2);
75912     } catch (std::out_of_range& e) {
75913       {
75914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75915       };
75916     } catch (std::exception& e) {
75917       {
75918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75919       };
75920     } catch (Dali::DaliException e) {
75921       {
75922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75923       };
75924     } catch (...) {
75925       {
75926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75927       };
75928     }
75929   }
75930
75931 }
75932
75933
75934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75935   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75936   unsigned int arg2 ;
75937
75938   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75939   arg2 = (unsigned int)jarg2;
75940   {
75941     try {
75942       (arg1)->RemoveLayout(arg2);
75943     } catch (std::out_of_range& e) {
75944       {
75945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75946       };
75947     } catch (std::exception& e) {
75948       {
75949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75950       };
75951     } catch (Dali::DaliException e) {
75952       {
75953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75954       };
75955     } catch (...) {
75956       {
75957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75958       };
75959     }
75960   }
75961
75962 }
75963
75964
75965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75966   void * jresult ;
75967   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75968   unsigned int arg2 ;
75969   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75970
75971   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75972   arg2 = (unsigned int)jarg2;
75973   {
75974     try {
75975       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75976     } catch (std::out_of_range& e) {
75977       {
75978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75979       };
75980     } catch (std::exception& e) {
75981       {
75982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75983       };
75984     } catch (Dali::DaliException e) {
75985       {
75986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75987       };
75988     } catch (...) {
75989       {
75990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75991       };
75992     }
75993   }
75994
75995   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75996   return jresult;
75997 }
75998
75999
76000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76001   void * jresult ;
76002   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76003   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76004
76005   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76006   {
76007     try {
76008       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76009     } catch (std::out_of_range& e) {
76010       {
76011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76012       };
76013     } catch (std::exception& e) {
76014       {
76015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76016       };
76017     } catch (Dali::DaliException e) {
76018       {
76019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76020       };
76021     } catch (...) {
76022       {
76023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76024       };
76025     }
76026   }
76027
76028   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76029   return jresult;
76030 }
76031
76032
76033 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76034   float jresult ;
76035   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76036   Dali::Toolkit::ItemId arg2 ;
76037   float result;
76038
76039   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76040   arg2 = (Dali::Toolkit::ItemId)jarg2;
76041   {
76042     try {
76043       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76044     } catch (std::out_of_range& e) {
76045       {
76046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76047       };
76048     } catch (std::exception& e) {
76049       {
76050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76051       };
76052     } catch (Dali::DaliException e) {
76053       {
76054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76055       };
76056     } catch (...) {
76057       {
76058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76059       };
76060     }
76061   }
76062
76063   jresult = result;
76064   return jresult;
76065 }
76066
76067
76068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76069   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76070   unsigned int arg2 ;
76071   Dali::Vector3 arg3 ;
76072   float arg4 ;
76073   Dali::Vector3 *argp3 ;
76074
76075   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76076   arg2 = (unsigned int)jarg2;
76077   argp3 = (Dali::Vector3 *)jarg3;
76078   if (!argp3) {
76079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76080     return ;
76081   }
76082   arg3 = *argp3;
76083   arg4 = (float)jarg4;
76084   {
76085     try {
76086       (arg1)->ActivateLayout(arg2,arg3,arg4);
76087     } catch (std::out_of_range& e) {
76088       {
76089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76090       };
76091     } catch (std::exception& e) {
76092       {
76093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76094       };
76095     } catch (Dali::DaliException e) {
76096       {
76097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76098       };
76099     } catch (...) {
76100       {
76101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76102       };
76103     }
76104   }
76105
76106 }
76107
76108
76109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76110   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76111
76112   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76113   {
76114     try {
76115       (arg1)->DeactivateCurrentLayout();
76116     } catch (std::out_of_range& e) {
76117       {
76118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76119       };
76120     } catch (std::exception& e) {
76121       {
76122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76123       };
76124     } catch (Dali::DaliException e) {
76125       {
76126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76127       };
76128     } catch (...) {
76129       {
76130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76131       };
76132     }
76133   }
76134
76135 }
76136
76137
76138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76139   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76140   float arg2 ;
76141
76142   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76143   arg2 = (float)jarg2;
76144   {
76145     try {
76146       (arg1)->SetMinimumSwipeSpeed(arg2);
76147     } catch (std::out_of_range& e) {
76148       {
76149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76150       };
76151     } catch (std::exception& e) {
76152       {
76153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76154       };
76155     } catch (Dali::DaliException e) {
76156       {
76157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76158       };
76159     } catch (...) {
76160       {
76161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76162       };
76163     }
76164   }
76165
76166 }
76167
76168
76169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76170   float jresult ;
76171   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76172   float result;
76173
76174   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76175   {
76176     try {
76177       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76178     } catch (std::out_of_range& e) {
76179       {
76180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76181       };
76182     } catch (std::exception& e) {
76183       {
76184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76185       };
76186     } catch (Dali::DaliException e) {
76187       {
76188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76189       };
76190     } catch (...) {
76191       {
76192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76193       };
76194     }
76195   }
76196
76197   jresult = result;
76198   return jresult;
76199 }
76200
76201
76202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76203   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76204   float arg2 ;
76205
76206   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76207   arg2 = (float)jarg2;
76208   {
76209     try {
76210       (arg1)->SetMinimumSwipeDistance(arg2);
76211     } catch (std::out_of_range& e) {
76212       {
76213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76214       };
76215     } catch (std::exception& e) {
76216       {
76217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76218       };
76219     } catch (Dali::DaliException e) {
76220       {
76221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76222       };
76223     } catch (...) {
76224       {
76225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76226       };
76227     }
76228   }
76229
76230 }
76231
76232
76233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76234   float jresult ;
76235   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76236   float result;
76237
76238   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76239   {
76240     try {
76241       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76242     } catch (std::out_of_range& e) {
76243       {
76244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76245       };
76246     } catch (std::exception& e) {
76247       {
76248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76249       };
76250     } catch (Dali::DaliException e) {
76251       {
76252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76253       };
76254     } catch (...) {
76255       {
76256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76257       };
76258     }
76259   }
76260
76261   jresult = result;
76262   return jresult;
76263 }
76264
76265
76266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76267   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76268   float arg2 ;
76269
76270   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76271   arg2 = (float)jarg2;
76272   {
76273     try {
76274       (arg1)->SetWheelScrollDistanceStep(arg2);
76275     } catch (std::out_of_range& e) {
76276       {
76277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76278       };
76279     } catch (std::exception& e) {
76280       {
76281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76282       };
76283     } catch (Dali::DaliException e) {
76284       {
76285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76286       };
76287     } catch (...) {
76288       {
76289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76290       };
76291     }
76292   }
76293
76294 }
76295
76296
76297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76298   float jresult ;
76299   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76300   float result;
76301
76302   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76303   {
76304     try {
76305       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76306     } catch (std::out_of_range& e) {
76307       {
76308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76309       };
76310     } catch (std::exception& e) {
76311       {
76312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76313       };
76314     } catch (Dali::DaliException e) {
76315       {
76316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76317       };
76318     } catch (...) {
76319       {
76320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76321       };
76322     }
76323   }
76324
76325   jresult = result;
76326   return jresult;
76327 }
76328
76329
76330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76331   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76332   bool arg2 ;
76333
76334   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76335   arg2 = jarg2 ? true : false;
76336   {
76337     try {
76338       (arg1)->SetAnchoring(arg2);
76339     } catch (std::out_of_range& e) {
76340       {
76341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76342       };
76343     } catch (std::exception& e) {
76344       {
76345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76346       };
76347     } catch (Dali::DaliException e) {
76348       {
76349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76350       };
76351     } catch (...) {
76352       {
76353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76354       };
76355     }
76356   }
76357
76358 }
76359
76360 //// ========================= end of part 3 =============================
76361
76362 //// ========================== start part 4 ===============================
76363
76364
76365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76366   unsigned int jresult ;
76367   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76368   bool result;
76369
76370   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76371   {
76372     try {
76373       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76374     } catch (std::out_of_range& e) {
76375       {
76376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76377       };
76378     } catch (std::exception& e) {
76379       {
76380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76381       };
76382     } catch (Dali::DaliException e) {
76383       {
76384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76385       };
76386     } catch (...) {
76387       {
76388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76389       };
76390     }
76391   }
76392
76393   jresult = result;
76394   return jresult;
76395 }
76396
76397
76398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76399   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76400   float arg2 ;
76401
76402   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76403   arg2 = (float)jarg2;
76404   {
76405     try {
76406       (arg1)->SetAnchoringDuration(arg2);
76407     } catch (std::out_of_range& e) {
76408       {
76409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76410       };
76411     } catch (std::exception& e) {
76412       {
76413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76414       };
76415     } catch (Dali::DaliException e) {
76416       {
76417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76418       };
76419     } catch (...) {
76420       {
76421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76422       };
76423     }
76424   }
76425
76426 }
76427
76428
76429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76430   float jresult ;
76431   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76432   float result;
76433
76434   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76435   {
76436     try {
76437       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76438     } catch (std::out_of_range& e) {
76439       {
76440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76441       };
76442     } catch (std::exception& e) {
76443       {
76444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76445       };
76446     } catch (Dali::DaliException e) {
76447       {
76448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76449       };
76450     } catch (...) {
76451       {
76452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76453       };
76454     }
76455   }
76456
76457   jresult = result;
76458   return jresult;
76459 }
76460
76461
76462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76463   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76464   Dali::Toolkit::ItemId arg2 ;
76465   float arg3 ;
76466
76467   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76468   arg2 = (Dali::Toolkit::ItemId)jarg2;
76469   arg3 = (float)jarg3;
76470   {
76471     try {
76472       (arg1)->ScrollToItem(arg2,arg3);
76473     } catch (std::out_of_range& e) {
76474       {
76475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76476       };
76477     } catch (std::exception& e) {
76478       {
76479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76480       };
76481     } catch (Dali::DaliException e) {
76482       {
76483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76484       };
76485     } catch (...) {
76486       {
76487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76488       };
76489     }
76490   }
76491
76492 }
76493
76494
76495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76496   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76497   float arg2 ;
76498
76499   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76500   arg2 = (float)jarg2;
76501   {
76502     try {
76503       (arg1)->SetRefreshInterval(arg2);
76504     } catch (std::out_of_range& e) {
76505       {
76506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76507       };
76508     } catch (std::exception& e) {
76509       {
76510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76511       };
76512     } catch (Dali::DaliException e) {
76513       {
76514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76515       };
76516     } catch (...) {
76517       {
76518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76519       };
76520     }
76521   }
76522
76523 }
76524
76525
76526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76527   float jresult ;
76528   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76529   float result;
76530
76531   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76532   {
76533     try {
76534       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76535     } catch (std::out_of_range& e) {
76536       {
76537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76538       };
76539     } catch (std::exception& e) {
76540       {
76541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76542       };
76543     } catch (Dali::DaliException e) {
76544       {
76545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76546       };
76547     } catch (...) {
76548       {
76549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76550       };
76551     }
76552   }
76553
76554   jresult = result;
76555   return jresult;
76556 }
76557
76558
76559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76560   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76561
76562   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76563   {
76564     try {
76565       (arg1)->Refresh();
76566     } catch (std::out_of_range& e) {
76567       {
76568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76569       };
76570     } catch (std::exception& e) {
76571       {
76572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76573       };
76574     } catch (Dali::DaliException e) {
76575       {
76576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76577       };
76578     } catch (...) {
76579       {
76580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76581       };
76582     }
76583   }
76584
76585 }
76586
76587
76588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76589   void * jresult ;
76590   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76591   Dali::Toolkit::ItemId arg2 ;
76592   Dali::Actor result;
76593
76594   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76595   arg2 = (Dali::Toolkit::ItemId)jarg2;
76596   {
76597     try {
76598       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76599     } catch (std::out_of_range& e) {
76600       {
76601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76602       };
76603     } catch (std::exception& e) {
76604       {
76605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76606       };
76607     } catch (Dali::DaliException e) {
76608       {
76609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76610       };
76611     } catch (...) {
76612       {
76613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76614       };
76615     }
76616   }
76617
76618   jresult = new Dali::Actor((const Dali::Actor &)result);
76619   return jresult;
76620 }
76621
76622
76623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76624   unsigned int jresult ;
76625   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76626   Dali::Actor arg2 ;
76627   Dali::Actor *argp2 ;
76628   Dali::Toolkit::ItemId result;
76629
76630   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76631   argp2 = (Dali::Actor *)jarg2;
76632   if (!argp2) {
76633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76634     return 0;
76635   }
76636   arg2 = *argp2;
76637   {
76638     try {
76639       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76640     } catch (std::out_of_range& e) {
76641       {
76642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76643       };
76644     } catch (std::exception& e) {
76645       {
76646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76647       };
76648     } catch (Dali::DaliException e) {
76649       {
76650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76651       };
76652     } catch (...) {
76653       {
76654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76655       };
76656     }
76657   }
76658
76659   jresult = result;
76660   return jresult;
76661 }
76662
76663
76664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76665   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76666   Dali::Toolkit::Item arg2 ;
76667   float arg3 ;
76668   Dali::Toolkit::Item *argp2 ;
76669
76670   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76671   argp2 = (Dali::Toolkit::Item *)jarg2;
76672   if (!argp2) {
76673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76674     return ;
76675   }
76676   arg2 = *argp2;
76677   arg3 = (float)jarg3;
76678   {
76679     try {
76680       (arg1)->InsertItem(arg2,arg3);
76681     } catch (std::out_of_range& e) {
76682       {
76683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76684       };
76685     } catch (std::exception& e) {
76686       {
76687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76688       };
76689     } catch (Dali::DaliException e) {
76690       {
76691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76692       };
76693     } catch (...) {
76694       {
76695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76696       };
76697     }
76698   }
76699
76700 }
76701
76702
76703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76704   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76705   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76706   float arg3 ;
76707
76708   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76709   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76710   if (!arg2) {
76711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76712     return ;
76713   }
76714   arg3 = (float)jarg3;
76715   {
76716     try {
76717       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76718     } catch (std::out_of_range& e) {
76719       {
76720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76721       };
76722     } catch (std::exception& e) {
76723       {
76724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76725       };
76726     } catch (Dali::DaliException e) {
76727       {
76728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76729       };
76730     } catch (...) {
76731       {
76732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76733       };
76734     }
76735   }
76736
76737 }
76738
76739
76740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76741   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76742   Dali::Toolkit::ItemId arg2 ;
76743   float arg3 ;
76744
76745   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76746   arg2 = (Dali::Toolkit::ItemId)jarg2;
76747   arg3 = (float)jarg3;
76748   {
76749     try {
76750       (arg1)->RemoveItem(arg2,arg3);
76751     } catch (std::out_of_range& e) {
76752       {
76753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76754       };
76755     } catch (std::exception& e) {
76756       {
76757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76758       };
76759     } catch (Dali::DaliException e) {
76760       {
76761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76762       };
76763     } catch (...) {
76764       {
76765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76766       };
76767     }
76768   }
76769
76770 }
76771
76772
76773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
76774   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76775   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
76776   float arg3 ;
76777
76778   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76779   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
76780   if (!arg2) {
76781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
76782     return ;
76783   }
76784   arg3 = (float)jarg3;
76785   {
76786     try {
76787       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
76788     } catch (std::out_of_range& e) {
76789       {
76790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76791       };
76792     } catch (std::exception& e) {
76793       {
76794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76795       };
76796     } catch (Dali::DaliException e) {
76797       {
76798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76799       };
76800     } catch (...) {
76801       {
76802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76803       };
76804     }
76805   }
76806
76807 }
76808
76809
76810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
76811   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76812   Dali::Toolkit::Item arg2 ;
76813   float arg3 ;
76814   Dali::Toolkit::Item *argp2 ;
76815
76816   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76817   argp2 = (Dali::Toolkit::Item *)jarg2;
76818   if (!argp2) {
76819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76820     return ;
76821   }
76822   arg2 = *argp2;
76823   arg3 = (float)jarg3;
76824   {
76825     try {
76826       (arg1)->ReplaceItem(arg2,arg3);
76827     } catch (std::out_of_range& e) {
76828       {
76829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76830       };
76831     } catch (std::exception& e) {
76832       {
76833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76834       };
76835     } catch (Dali::DaliException e) {
76836       {
76837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76838       };
76839     } catch (...) {
76840       {
76841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76842       };
76843     }
76844   }
76845
76846 }
76847
76848
76849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
76850   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76851   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76852   float arg3 ;
76853
76854   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76855   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76856   if (!arg2) {
76857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76858     return ;
76859   }
76860   arg3 = (float)jarg3;
76861   {
76862     try {
76863       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76864     } catch (std::out_of_range& e) {
76865       {
76866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76867       };
76868     } catch (std::exception& e) {
76869       {
76870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76871       };
76872     } catch (Dali::DaliException e) {
76873       {
76874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76875       };
76876     } catch (...) {
76877       {
76878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76879       };
76880     }
76881   }
76882
76883 }
76884
76885
76886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
76887   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76888   Dali::Vector3 *arg2 = 0 ;
76889
76890   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76891   arg2 = (Dali::Vector3 *)jarg2;
76892   if (!arg2) {
76893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76894     return ;
76895   }
76896   {
76897     try {
76898       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
76899     } catch (std::out_of_range& e) {
76900       {
76901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76902       };
76903     } catch (std::exception& e) {
76904       {
76905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76906       };
76907     } catch (Dali::DaliException e) {
76908       {
76909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76910       };
76911     } catch (...) {
76912       {
76913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76914       };
76915     }
76916   }
76917
76918 }
76919
76920
76921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
76922   void * jresult ;
76923   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76924   Dali::Vector3 result;
76925
76926   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76927   {
76928     try {
76929       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
76930     } catch (std::out_of_range& e) {
76931       {
76932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76933       };
76934     } catch (std::exception& e) {
76935       {
76936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76937       };
76938     } catch (Dali::DaliException e) {
76939       {
76940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76941       };
76942     } catch (...) {
76943       {
76944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76945       };
76946     }
76947   }
76948
76949   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76950   return jresult;
76951 }
76952
76953
76954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76955   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76956   Dali::Vector3 *arg2 = 0 ;
76957
76958   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76959   arg2 = (Dali::Vector3 *)jarg2;
76960   if (!arg2) {
76961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76962     return ;
76963   }
76964   {
76965     try {
76966       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76967     } catch (std::out_of_range& e) {
76968       {
76969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76970       };
76971     } catch (std::exception& e) {
76972       {
76973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76974       };
76975     } catch (Dali::DaliException e) {
76976       {
76977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76978       };
76979     } catch (...) {
76980       {
76981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76982       };
76983     }
76984   }
76985
76986 }
76987
76988
76989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76990   void * jresult ;
76991   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76992   Dali::Vector3 result;
76993
76994   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76995   {
76996     try {
76997       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76998     } catch (std::out_of_range& e) {
76999       {
77000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77001       };
77002     } catch (std::exception& e) {
77003       {
77004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77005       };
77006     } catch (Dali::DaliException e) {
77007       {
77008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77009       };
77010     } catch (...) {
77011       {
77012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77013       };
77014     }
77015   }
77016
77017   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77018   return jresult;
77019 }
77020
77021
77022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77023   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77024   Dali::Toolkit::ItemRange *arg2 = 0 ;
77025
77026   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77027   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77028   if (!arg2) {
77029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77030     return ;
77031   }
77032   {
77033     try {
77034       (arg1)->GetItemsRange(*arg2);
77035     } catch (std::out_of_range& e) {
77036       {
77037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77038       };
77039     } catch (std::exception& e) {
77040       {
77041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77042       };
77043     } catch (Dali::DaliException e) {
77044       {
77045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77046       };
77047     } catch (...) {
77048       {
77049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77050       };
77051     }
77052   }
77053
77054 }
77055
77056
77057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77058   void * jresult ;
77059   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77060   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77061
77062   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77063   {
77064     try {
77065       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77066     } catch (std::out_of_range& e) {
77067       {
77068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77069       };
77070     } catch (std::exception& e) {
77071       {
77072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77073       };
77074     } catch (Dali::DaliException e) {
77075       {
77076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77077       };
77078     } catch (...) {
77079       {
77080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77081       };
77082     }
77083   }
77084
77085   jresult = (void *)result;
77086   return jresult;
77087 }
77088
77089
77090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77091   Dali::Vector3 *arg1 = 0 ;
77092   PropertyInputContainer *arg2 = 0 ;
77093
77094   arg1 = (Dali::Vector3 *)jarg1;
77095   if (!arg1) {
77096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77097     return ;
77098   }
77099   arg2 = (PropertyInputContainer *)jarg2;
77100   if (!arg2) {
77101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77102     return ;
77103   }
77104   {
77105     try {
77106       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77107     } catch (std::out_of_range& e) {
77108       {
77109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77110       };
77111     } catch (std::exception& e) {
77112       {
77113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77114       };
77115     } catch (Dali::DaliException e) {
77116       {
77117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77118       };
77119     } catch (...) {
77120       {
77121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77122       };
77123     }
77124   }
77125
77126 }
77127
77128
77129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77130   Dali::Vector3 *arg1 = 0 ;
77131   PropertyInputContainer *arg2 = 0 ;
77132
77133   arg1 = (Dali::Vector3 *)jarg1;
77134   if (!arg1) {
77135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77136     return ;
77137   }
77138   arg2 = (PropertyInputContainer *)jarg2;
77139   if (!arg2) {
77140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77141     return ;
77142   }
77143   {
77144     try {
77145       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77146     } catch (std::out_of_range& e) {
77147       {
77148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77149       };
77150     } catch (std::exception& e) {
77151       {
77152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77153       };
77154     } catch (Dali::DaliException e) {
77155       {
77156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77157       };
77158     } catch (...) {
77159       {
77160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77161       };
77162     }
77163   }
77164
77165 }
77166
77167
77168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77169   void * jresult ;
77170   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77171
77172   {
77173     try {
77174       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77175     } catch (std::out_of_range& e) {
77176       {
77177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77178       };
77179     } catch (std::exception& e) {
77180       {
77181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77182       };
77183     } catch (Dali::DaliException e) {
77184       {
77185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77186       };
77187     } catch (...) {
77188       {
77189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77190       };
77191     }
77192   }
77193
77194   jresult = (void *)result;
77195   return jresult;
77196 }
77197
77198
77199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77200   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77201
77202   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77203   {
77204     try {
77205       delete arg1;
77206     } catch (std::out_of_range& e) {
77207       {
77208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77209       };
77210     } catch (std::exception& e) {
77211       {
77212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77213       };
77214     } catch (Dali::DaliException e) {
77215       {
77216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77217       };
77218     } catch (...) {
77219       {
77220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77221       };
77222     }
77223   }
77224
77225 }
77226
77227
77228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77229   void * jresult ;
77230   Dali::Path arg1 ;
77231   Dali::Vector3 *arg2 = 0 ;
77232   Dali::Property::Index arg3 ;
77233   Dali::Vector3 *arg4 = 0 ;
77234   unsigned int arg5 ;
77235   Dali::Path *argp1 ;
77236   Dali::Toolkit::ScrollViewPagePathEffect result;
77237
77238   argp1 = (Dali::Path *)jarg1;
77239   if (!argp1) {
77240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77241     return 0;
77242   }
77243   arg1 = *argp1;
77244   arg2 = (Dali::Vector3 *)jarg2;
77245   if (!arg2) {
77246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77247     return 0;
77248   }
77249   arg3 = (Dali::Property::Index)jarg3;
77250   arg4 = (Dali::Vector3 *)jarg4;
77251   if (!arg4) {
77252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77253     return 0;
77254   }
77255   arg5 = (unsigned int)jarg5;
77256   {
77257     try {
77258       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77259     } catch (std::out_of_range& e) {
77260       {
77261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77262       };
77263     } catch (std::exception& e) {
77264       {
77265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77266       };
77267     } catch (Dali::DaliException e) {
77268       {
77269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77270       };
77271     } catch (...) {
77272       {
77273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77274       };
77275     }
77276   }
77277
77278   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77279   return jresult;
77280 }
77281
77282
77283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77284   void * jresult ;
77285   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77286
77287   {
77288     try {
77289       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77290     } catch (std::out_of_range& e) {
77291       {
77292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77293       };
77294     } catch (std::exception& e) {
77295       {
77296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77297       };
77298     } catch (Dali::DaliException e) {
77299       {
77300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77301       };
77302     } catch (...) {
77303       {
77304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77305       };
77306     }
77307   }
77308
77309   jresult = (void *)result;
77310   return jresult;
77311 }
77312
77313
77314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77315   void * jresult ;
77316   Dali::BaseHandle arg1 ;
77317   Dali::BaseHandle *argp1 ;
77318   Dali::Toolkit::ScrollViewPagePathEffect result;
77319
77320   argp1 = (Dali::BaseHandle *)jarg1;
77321   if (!argp1) {
77322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77323     return 0;
77324   }
77325   arg1 = *argp1;
77326   {
77327     try {
77328       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77329     } catch (std::out_of_range& e) {
77330       {
77331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77332       };
77333     } catch (std::exception& e) {
77334       {
77335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77336       };
77337     } catch (Dali::DaliException e) {
77338       {
77339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77340       };
77341     } catch (...) {
77342       {
77343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77344       };
77345     }
77346   }
77347
77348   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77349   return jresult;
77350 }
77351
77352
77353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77354   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77355   Dali::Actor arg2 ;
77356   unsigned int arg3 ;
77357   Dali::Actor *argp2 ;
77358
77359   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77360   argp2 = (Dali::Actor *)jarg2;
77361   if (!argp2) {
77362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77363     return ;
77364   }
77365   arg2 = *argp2;
77366   arg3 = (unsigned int)jarg3;
77367   {
77368     try {
77369       (arg1)->ApplyToPage(arg2,arg3);
77370     } catch (std::out_of_range& e) {
77371       {
77372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77373       };
77374     } catch (std::exception& e) {
77375       {
77376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77377       };
77378     } catch (Dali::DaliException e) {
77379       {
77380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77381       };
77382     } catch (...) {
77383       {
77384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77385       };
77386     }
77387   }
77388
77389 }
77390
77391
77392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77393   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77394
77395   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77396   {
77397     try {
77398       delete arg1;
77399     } catch (std::out_of_range& e) {
77400       {
77401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77402       };
77403     } catch (std::exception& e) {
77404       {
77405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77406       };
77407     } catch (Dali::DaliException e) {
77408       {
77409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77410       };
77411     } catch (...) {
77412       {
77413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77414       };
77415     }
77416   }
77417
77418 }
77419
77420
77421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77422   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77423   Dali::Toolkit::ClampState arg2 ;
77424
77425   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77426   arg2 = (Dali::Toolkit::ClampState)jarg2;
77427   if (arg1) (arg1)->x = arg2;
77428 }
77429
77430
77431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77432   int jresult ;
77433   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77434   Dali::Toolkit::ClampState result;
77435
77436   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77437   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77438   jresult = (int)result;
77439   return jresult;
77440 }
77441
77442
77443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77444   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77445   Dali::Toolkit::ClampState arg2 ;
77446
77447   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77448   arg2 = (Dali::Toolkit::ClampState)jarg2;
77449   if (arg1) (arg1)->y = arg2;
77450 }
77451
77452
77453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77454   int jresult ;
77455   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77456   Dali::Toolkit::ClampState result;
77457
77458   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77459   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77460   jresult = (int)result;
77461   return jresult;
77462 }
77463
77464
77465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77466   void * jresult ;
77467   Dali::Toolkit::ClampState2D *result = 0 ;
77468
77469   {
77470     try {
77471       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77472     } catch (std::out_of_range& e) {
77473       {
77474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77475       };
77476     } catch (std::exception& e) {
77477       {
77478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77479       };
77480     } catch (Dali::DaliException e) {
77481       {
77482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77483       };
77484     } catch (...) {
77485       {
77486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77487       };
77488     }
77489   }
77490
77491   jresult = (void *)result;
77492   return jresult;
77493 }
77494
77495
77496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77497   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77498
77499   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77500   {
77501     try {
77502       delete arg1;
77503     } catch (std::out_of_range& e) {
77504       {
77505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77506       };
77507     } catch (std::exception& e) {
77508       {
77509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77510       };
77511     } catch (Dali::DaliException e) {
77512       {
77513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77514       };
77515     } catch (...) {
77516       {
77517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77518       };
77519     }
77520   }
77521
77522 }
77523
77524
77525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77526   void * jresult ;
77527   float arg1 ;
77528   float arg2 ;
77529   bool arg3 ;
77530   Dali::Toolkit::RulerDomain *result = 0 ;
77531
77532   arg1 = (float)jarg1;
77533   arg2 = (float)jarg2;
77534   arg3 = jarg3 ? true : false;
77535   {
77536     try {
77537       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77538     } catch (std::out_of_range& e) {
77539       {
77540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77541       };
77542     } catch (std::exception& e) {
77543       {
77544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77545       };
77546     } catch (Dali::DaliException e) {
77547       {
77548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77549       };
77550     } catch (...) {
77551       {
77552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77553       };
77554     }
77555   }
77556
77557   jresult = (void *)result;
77558   return jresult;
77559 }
77560
77561
77562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77563   void * jresult ;
77564   float arg1 ;
77565   float arg2 ;
77566   Dali::Toolkit::RulerDomain *result = 0 ;
77567
77568   arg1 = (float)jarg1;
77569   arg2 = (float)jarg2;
77570   {
77571     try {
77572       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77573     } catch (std::out_of_range& e) {
77574       {
77575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77576       };
77577     } catch (std::exception& e) {
77578       {
77579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77580       };
77581     } catch (Dali::DaliException e) {
77582       {
77583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77584       };
77585     } catch (...) {
77586       {
77587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77588       };
77589     }
77590   }
77591
77592   jresult = (void *)result;
77593   return jresult;
77594 }
77595
77596
77597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77598   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77599   float arg2 ;
77600
77601   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77602   arg2 = (float)jarg2;
77603   if (arg1) (arg1)->min = arg2;
77604 }
77605
77606
77607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77608   float jresult ;
77609   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77610   float result;
77611
77612   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77613   result = (float) ((arg1)->min);
77614   jresult = result;
77615   return jresult;
77616 }
77617
77618
77619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77620   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77621   float arg2 ;
77622
77623   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77624   arg2 = (float)jarg2;
77625   if (arg1) (arg1)->max = arg2;
77626 }
77627
77628
77629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77630   float jresult ;
77631   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77632   float result;
77633
77634   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77635   result = (float) ((arg1)->max);
77636   jresult = result;
77637   return jresult;
77638 }
77639
77640
77641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77642   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77643   bool arg2 ;
77644
77645   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77646   arg2 = jarg2 ? true : false;
77647   if (arg1) (arg1)->enabled = arg2;
77648 }
77649
77650
77651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77652   unsigned int jresult ;
77653   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77654   bool result;
77655
77656   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77657   result = (bool) ((arg1)->enabled);
77658   jresult = result;
77659   return jresult;
77660 }
77661
77662
77663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77664   float jresult ;
77665   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77666   float arg2 ;
77667   float arg3 ;
77668   float arg4 ;
77669   float result;
77670
77671   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77672   arg2 = (float)jarg2;
77673   arg3 = (float)jarg3;
77674   arg4 = (float)jarg4;
77675   {
77676     try {
77677       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77678     } catch (std::out_of_range& e) {
77679       {
77680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77681       };
77682     } catch (std::exception& e) {
77683       {
77684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77685       };
77686     } catch (Dali::DaliException e) {
77687       {
77688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77689       };
77690     } catch (...) {
77691       {
77692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77693       };
77694     }
77695   }
77696
77697   jresult = result;
77698   return jresult;
77699 }
77700
77701
77702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77703   float jresult ;
77704   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77705   float arg2 ;
77706   float arg3 ;
77707   float result;
77708
77709   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77710   arg2 = (float)jarg2;
77711   arg3 = (float)jarg3;
77712   {
77713     try {
77714       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77715     } catch (std::out_of_range& e) {
77716       {
77717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77718       };
77719     } catch (std::exception& e) {
77720       {
77721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77722       };
77723     } catch (Dali::DaliException e) {
77724       {
77725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77726       };
77727     } catch (...) {
77728       {
77729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77730       };
77731     }
77732   }
77733
77734   jresult = result;
77735   return jresult;
77736 }
77737
77738
77739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77740   float jresult ;
77741   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77742   float arg2 ;
77743   float result;
77744
77745   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77746   arg2 = (float)jarg2;
77747   {
77748     try {
77749       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77750     } catch (std::out_of_range& e) {
77751       {
77752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77753       };
77754     } catch (std::exception& e) {
77755       {
77756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77757       };
77758     } catch (Dali::DaliException e) {
77759       {
77760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77761       };
77762     } catch (...) {
77763       {
77764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77765       };
77766     }
77767   }
77768
77769   jresult = result;
77770   return jresult;
77771 }
77772
77773
77774 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77775   float jresult ;
77776   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77777   float arg2 ;
77778   float arg3 ;
77779   float arg4 ;
77780   Dali::Toolkit::ClampState *arg5 = 0 ;
77781   float result;
77782
77783   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77784   arg2 = (float)jarg2;
77785   arg3 = (float)jarg3;
77786   arg4 = (float)jarg4;
77787   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77788   if (!arg5) {
77789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77790     return 0;
77791   }
77792   {
77793     try {
77794       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77795     } catch (std::out_of_range& e) {
77796       {
77797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77798       };
77799     } catch (std::exception& e) {
77800       {
77801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77802       };
77803     } catch (Dali::DaliException e) {
77804       {
77805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77806       };
77807     } catch (...) {
77808       {
77809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77810       };
77811     }
77812   }
77813
77814   jresult = result;
77815   return jresult;
77816 }
77817
77818
77819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
77820   float jresult ;
77821   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77822   float result;
77823
77824   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77825   {
77826     try {
77827       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
77828     } catch (std::out_of_range& e) {
77829       {
77830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77831       };
77832     } catch (std::exception& e) {
77833       {
77834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77835       };
77836     } catch (Dali::DaliException e) {
77837       {
77838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77839       };
77840     } catch (...) {
77841       {
77842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77843       };
77844     }
77845   }
77846
77847   jresult = result;
77848   return jresult;
77849 }
77850
77851
77852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
77853   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77854
77855   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77856   {
77857     try {
77858       delete arg1;
77859     } catch (std::out_of_range& e) {
77860       {
77861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77862       };
77863     } catch (std::exception& e) {
77864       {
77865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77866       };
77867     } catch (Dali::DaliException e) {
77868       {
77869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77870       };
77871     } catch (...) {
77872       {
77873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77874       };
77875     }
77876   }
77877
77878 }
77879
77880
77881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
77882   float jresult ;
77883   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77884   float arg2 ;
77885   float arg3 ;
77886   float result;
77887
77888   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77889   arg2 = (float)jarg2;
77890   arg3 = (float)jarg3;
77891   {
77892     try {
77893       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
77894     } catch (std::out_of_range& e) {
77895       {
77896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77897       };
77898     } catch (std::exception& e) {
77899       {
77900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77901       };
77902     } catch (Dali::DaliException e) {
77903       {
77904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77905       };
77906     } catch (...) {
77907       {
77908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77909       };
77910     }
77911   }
77912
77913   jresult = result;
77914   return jresult;
77915 }
77916
77917
77918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
77919   float jresult ;
77920   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77921   float arg2 ;
77922   float result;
77923
77924   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77925   arg2 = (float)jarg2;
77926   {
77927     try {
77928       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
77929     } catch (std::out_of_range& e) {
77930       {
77931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77932       };
77933     } catch (std::exception& e) {
77934       {
77935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77936       };
77937     } catch (Dali::DaliException e) {
77938       {
77939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77940       };
77941     } catch (...) {
77942       {
77943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77944       };
77945     }
77946   }
77947
77948   jresult = result;
77949   return jresult;
77950 }
77951
77952
77953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77954   float jresult ;
77955   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77956   unsigned int arg2 ;
77957   unsigned int *arg3 = 0 ;
77958   bool arg4 ;
77959   float result;
77960
77961   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77962   arg2 = (unsigned int)jarg2;
77963   arg3 = (unsigned int *)jarg3;
77964   arg4 = jarg4 ? true : false;
77965   {
77966     try {
77967       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77968     } catch (std::out_of_range& e) {
77969       {
77970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77971       };
77972     } catch (std::exception& e) {
77973       {
77974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77975       };
77976     } catch (Dali::DaliException e) {
77977       {
77978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77979       };
77980     } catch (...) {
77981       {
77982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77983       };
77984     }
77985   }
77986
77987   jresult = result;
77988   return jresult;
77989 }
77990
77991
77992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77993   unsigned int jresult ;
77994   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77995   float arg2 ;
77996   bool arg3 ;
77997   unsigned int result;
77998
77999   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78000   arg2 = (float)jarg2;
78001   arg3 = jarg3 ? true : false;
78002   {
78003     try {
78004       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78005     } catch (std::out_of_range& e) {
78006       {
78007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78008       };
78009     } catch (std::exception& e) {
78010       {
78011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78012       };
78013     } catch (Dali::DaliException e) {
78014       {
78015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78016       };
78017     } catch (...) {
78018       {
78019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78020       };
78021     }
78022   }
78023
78024   jresult = result;
78025   return jresult;
78026 }
78027
78028
78029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78030   unsigned int jresult ;
78031   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78032   unsigned int result;
78033
78034   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78035   {
78036     try {
78037       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78038     } catch (std::out_of_range& e) {
78039       {
78040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78041       };
78042     } catch (std::exception& e) {
78043       {
78044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78045       };
78046     } catch (Dali::DaliException e) {
78047       {
78048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78049       };
78050     } catch (...) {
78051       {
78052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78053       };
78054     }
78055   }
78056
78057   jresult = result;
78058   return jresult;
78059 }
78060
78061
78062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78063   int jresult ;
78064   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78065   Dali::Toolkit::Ruler::RulerType result;
78066
78067   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78068   {
78069     try {
78070       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78071     } catch (std::out_of_range& e) {
78072       {
78073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78074       };
78075     } catch (std::exception& e) {
78076       {
78077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78078       };
78079     } catch (Dali::DaliException e) {
78080       {
78081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78082       };
78083     } catch (...) {
78084       {
78085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78086       };
78087     }
78088   }
78089
78090   jresult = (int)result;
78091   return jresult;
78092 }
78093
78094
78095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78096   unsigned int jresult ;
78097   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78098   bool result;
78099
78100   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78101   {
78102     try {
78103       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78104     } catch (std::out_of_range& e) {
78105       {
78106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78107       };
78108     } catch (std::exception& e) {
78109       {
78110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78111       };
78112     } catch (Dali::DaliException e) {
78113       {
78114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78115       };
78116     } catch (...) {
78117       {
78118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78119       };
78120     }
78121   }
78122
78123   jresult = result;
78124   return jresult;
78125 }
78126
78127
78128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78129   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78130
78131   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78132   {
78133     try {
78134       (arg1)->Enable();
78135     } catch (std::out_of_range& e) {
78136       {
78137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78138       };
78139     } catch (std::exception& e) {
78140       {
78141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78142       };
78143     } catch (Dali::DaliException e) {
78144       {
78145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78146       };
78147     } catch (...) {
78148       {
78149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78150       };
78151     }
78152   }
78153
78154 }
78155
78156
78157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78158   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78159
78160   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78161   {
78162     try {
78163       (arg1)->Disable();
78164     } catch (std::out_of_range& e) {
78165       {
78166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78167       };
78168     } catch (std::exception& e) {
78169       {
78170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78171       };
78172     } catch (Dali::DaliException e) {
78173       {
78174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78175       };
78176     } catch (...) {
78177       {
78178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78179       };
78180     }
78181   }
78182
78183 }
78184
78185
78186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78187   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78188   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78189   Dali::Toolkit::RulerDomain *argp2 ;
78190
78191   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78192   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78193   if (!argp2) {
78194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78195     return ;
78196   }
78197   arg2 = *argp2;
78198   {
78199     try {
78200       (arg1)->SetDomain(arg2);
78201     } catch (std::out_of_range& e) {
78202       {
78203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78204       };
78205     } catch (std::exception& e) {
78206       {
78207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78208       };
78209     } catch (Dali::DaliException e) {
78210       {
78211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78212       };
78213     } catch (...) {
78214       {
78215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78216       };
78217     }
78218   }
78219
78220 }
78221
78222
78223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78224   void * jresult ;
78225   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78226   Dali::Toolkit::RulerDomain *result = 0 ;
78227
78228   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78229   {
78230     try {
78231       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78232     } catch (std::out_of_range& e) {
78233       {
78234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78235       };
78236     } catch (std::exception& e) {
78237       {
78238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78239       };
78240     } catch (Dali::DaliException e) {
78241       {
78242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78243       };
78244     } catch (...) {
78245       {
78246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78247       };
78248     }
78249   }
78250
78251   jresult = (void *)result;
78252   return jresult;
78253 }
78254
78255
78256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78257   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78258
78259   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78260   {
78261     try {
78262       (arg1)->DisableDomain();
78263     } catch (std::out_of_range& e) {
78264       {
78265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78266       };
78267     } catch (std::exception& e) {
78268       {
78269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78270       };
78271     } catch (Dali::DaliException e) {
78272       {
78273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78274       };
78275     } catch (...) {
78276       {
78277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78278       };
78279     }
78280   }
78281
78282 }
78283
78284
78285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78286   float jresult ;
78287   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78288   float arg2 ;
78289   float arg3 ;
78290   float arg4 ;
78291   float result;
78292
78293   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78294   arg2 = (float)jarg2;
78295   arg3 = (float)jarg3;
78296   arg4 = (float)jarg4;
78297   {
78298     try {
78299       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78300     } catch (std::out_of_range& e) {
78301       {
78302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78303       };
78304     } catch (std::exception& e) {
78305       {
78306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78307       };
78308     } catch (Dali::DaliException e) {
78309       {
78310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78311       };
78312     } catch (...) {
78313       {
78314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78315       };
78316     }
78317   }
78318
78319   jresult = result;
78320   return jresult;
78321 }
78322
78323
78324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78325   float jresult ;
78326   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78327   float arg2 ;
78328   float arg3 ;
78329   float result;
78330
78331   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78332   arg2 = (float)jarg2;
78333   arg3 = (float)jarg3;
78334   {
78335     try {
78336       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78337     } catch (std::out_of_range& e) {
78338       {
78339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78340       };
78341     } catch (std::exception& e) {
78342       {
78343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78344       };
78345     } catch (Dali::DaliException e) {
78346       {
78347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78348       };
78349     } catch (...) {
78350       {
78351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78352       };
78353     }
78354   }
78355
78356   jresult = result;
78357   return jresult;
78358 }
78359
78360
78361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78362   float jresult ;
78363   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78364   float arg2 ;
78365   float result;
78366
78367   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78368   arg2 = (float)jarg2;
78369   {
78370     try {
78371       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78372     } catch (std::out_of_range& e) {
78373       {
78374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78375       };
78376     } catch (std::exception& e) {
78377       {
78378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78379       };
78380     } catch (Dali::DaliException e) {
78381       {
78382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78383       };
78384     } catch (...) {
78385       {
78386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78387       };
78388     }
78389   }
78390
78391   jresult = result;
78392   return jresult;
78393 }
78394
78395
78396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78397   float jresult ;
78398   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78399   float arg2 ;
78400   float arg3 ;
78401   float arg4 ;
78402   Dali::Toolkit::ClampState *arg5 = 0 ;
78403   float result;
78404
78405   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78406   arg2 = (float)jarg2;
78407   arg3 = (float)jarg3;
78408   arg4 = (float)jarg4;
78409   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78410   if (!arg5) {
78411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78412     return 0;
78413   }
78414   {
78415     try {
78416       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78417     } catch (std::out_of_range& e) {
78418       {
78419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78420       };
78421     } catch (std::exception& e) {
78422       {
78423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78424       };
78425     } catch (Dali::DaliException e) {
78426       {
78427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78428       };
78429     } catch (...) {
78430       {
78431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78432       };
78433     }
78434   }
78435
78436   jresult = result;
78437   return jresult;
78438 }
78439
78440
78441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78442   float jresult ;
78443   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78444   float arg2 ;
78445   float arg3 ;
78446   float arg4 ;
78447   float arg5 ;
78448   float result;
78449
78450   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78451   arg2 = (float)jarg2;
78452   arg3 = (float)jarg3;
78453   arg4 = (float)jarg4;
78454   arg5 = (float)jarg5;
78455   {
78456     try {
78457       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78458     } catch (std::out_of_range& e) {
78459       {
78460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78461       };
78462     } catch (std::exception& e) {
78463       {
78464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78465       };
78466     } catch (Dali::DaliException e) {
78467       {
78468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78469       };
78470     } catch (...) {
78471       {
78472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78473       };
78474     }
78475   }
78476
78477   jresult = result;
78478   return jresult;
78479 }
78480
78481
78482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78483   float jresult ;
78484   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78485   float arg2 ;
78486   float arg3 ;
78487   float arg4 ;
78488   float result;
78489
78490   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78491   arg2 = (float)jarg2;
78492   arg3 = (float)jarg3;
78493   arg4 = (float)jarg4;
78494   {
78495     try {
78496       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78497     } catch (std::out_of_range& e) {
78498       {
78499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78500       };
78501     } catch (std::exception& e) {
78502       {
78503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78504       };
78505     } catch (Dali::DaliException e) {
78506       {
78507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78508       };
78509     } catch (...) {
78510       {
78511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78512       };
78513     }
78514   }
78515
78516   jresult = result;
78517   return jresult;
78518 }
78519
78520
78521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78522   float jresult ;
78523   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78524   float arg2 ;
78525   float arg3 ;
78526   float result;
78527
78528   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78529   arg2 = (float)jarg2;
78530   arg3 = (float)jarg3;
78531   {
78532     try {
78533       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78534     } catch (std::out_of_range& e) {
78535       {
78536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78537       };
78538     } catch (std::exception& e) {
78539       {
78540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78541       };
78542     } catch (Dali::DaliException e) {
78543       {
78544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78545       };
78546     } catch (...) {
78547       {
78548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78549       };
78550     }
78551   }
78552
78553   jresult = result;
78554   return jresult;
78555 }
78556
78557
78558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78559   float jresult ;
78560   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78561   float arg2 ;
78562   float result;
78563
78564   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78565   arg2 = (float)jarg2;
78566   {
78567     try {
78568       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78569     } catch (std::out_of_range& e) {
78570       {
78571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78572       };
78573     } catch (std::exception& e) {
78574       {
78575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78576       };
78577     } catch (Dali::DaliException e) {
78578       {
78579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78580       };
78581     } catch (...) {
78582       {
78583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78584       };
78585     }
78586   }
78587
78588   jresult = result;
78589   return jresult;
78590 }
78591
78592
78593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78594   float jresult ;
78595   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78596   float arg2 ;
78597   float arg3 ;
78598   float arg4 ;
78599   float arg5 ;
78600   Dali::Toolkit::ClampState *arg6 = 0 ;
78601   float result;
78602
78603   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78604   arg2 = (float)jarg2;
78605   arg3 = (float)jarg3;
78606   arg4 = (float)jarg4;
78607   arg5 = (float)jarg5;
78608   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78609   if (!arg6) {
78610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78611     return 0;
78612   }
78613   {
78614     try {
78615       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78616     } catch (std::out_of_range& e) {
78617       {
78618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78619       };
78620     } catch (std::exception& e) {
78621       {
78622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78623       };
78624     } catch (Dali::DaliException e) {
78625       {
78626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78627       };
78628     } catch (...) {
78629       {
78630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78631       };
78632     }
78633   }
78634
78635   jresult = result;
78636   return jresult;
78637 }
78638
78639
78640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78641   void * jresult ;
78642   Dali::Toolkit::DefaultRuler *result = 0 ;
78643
78644   {
78645     try {
78646       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78647     } catch (std::out_of_range& e) {
78648       {
78649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78650       };
78651     } catch (std::exception& e) {
78652       {
78653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78654       };
78655     } catch (Dali::DaliException e) {
78656       {
78657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78658       };
78659     } catch (...) {
78660       {
78661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78662       };
78663     }
78664   }
78665
78666   jresult = (void *)result;
78667   return jresult;
78668 }
78669
78670
78671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78672   float jresult ;
78673   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78674   float arg2 ;
78675   float arg3 ;
78676   float result;
78677
78678   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78679   arg2 = (float)jarg2;
78680   arg3 = (float)jarg3;
78681   {
78682     try {
78683       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78684     } catch (std::out_of_range& e) {
78685       {
78686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78687       };
78688     } catch (std::exception& e) {
78689       {
78690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78691       };
78692     } catch (Dali::DaliException e) {
78693       {
78694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78695       };
78696     } catch (...) {
78697       {
78698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78699       };
78700     }
78701   }
78702
78703   jresult = result;
78704   return jresult;
78705 }
78706
78707
78708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78709   float jresult ;
78710   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78711   unsigned int arg2 ;
78712   unsigned int *arg3 = 0 ;
78713   bool arg4 ;
78714   float result;
78715
78716   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78717   arg2 = (unsigned int)jarg2;
78718   arg3 = (unsigned int *)jarg3;
78719   arg4 = jarg4 ? true : false;
78720   {
78721     try {
78722       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78723     } catch (std::out_of_range& e) {
78724       {
78725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78726       };
78727     } catch (std::exception& e) {
78728       {
78729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78730       };
78731     } catch (Dali::DaliException e) {
78732       {
78733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78734       };
78735     } catch (...) {
78736       {
78737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78738       };
78739     }
78740   }
78741
78742   jresult = result;
78743   return jresult;
78744 }
78745
78746
78747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78748   unsigned int jresult ;
78749   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78750   float arg2 ;
78751   bool arg3 ;
78752   unsigned int result;
78753
78754   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78755   arg2 = (float)jarg2;
78756   arg3 = jarg3 ? true : false;
78757   {
78758     try {
78759       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78760     } catch (std::out_of_range& e) {
78761       {
78762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78763       };
78764     } catch (std::exception& e) {
78765       {
78766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78767       };
78768     } catch (Dali::DaliException e) {
78769       {
78770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78771       };
78772     } catch (...) {
78773       {
78774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78775       };
78776     }
78777   }
78778
78779   jresult = result;
78780   return jresult;
78781 }
78782
78783
78784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
78785   unsigned int jresult ;
78786   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78787   unsigned int result;
78788
78789   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78790   {
78791     try {
78792       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
78793     } catch (std::out_of_range& e) {
78794       {
78795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78796       };
78797     } catch (std::exception& e) {
78798       {
78799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78800       };
78801     } catch (Dali::DaliException e) {
78802       {
78803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78804       };
78805     } catch (...) {
78806       {
78807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78808       };
78809     }
78810   }
78811
78812   jresult = result;
78813   return jresult;
78814 }
78815
78816
78817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
78818   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78819
78820   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78821   {
78822     try {
78823       delete arg1;
78824     } catch (std::out_of_range& e) {
78825       {
78826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78827       };
78828     } catch (std::exception& e) {
78829       {
78830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78831       };
78832     } catch (Dali::DaliException e) {
78833       {
78834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78835       };
78836     } catch (...) {
78837       {
78838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78839       };
78840     }
78841   }
78842
78843 }
78844
78845
78846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
78847   void * jresult ;
78848   float arg1 ;
78849   Dali::Toolkit::FixedRuler *result = 0 ;
78850
78851   arg1 = (float)jarg1;
78852   {
78853     try {
78854       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
78855     } catch (std::out_of_range& e) {
78856       {
78857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78858       };
78859     } catch (std::exception& e) {
78860       {
78861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78862       };
78863     } catch (Dali::DaliException e) {
78864       {
78865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78866       };
78867     } catch (...) {
78868       {
78869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78870       };
78871     }
78872   }
78873
78874   jresult = (void *)result;
78875   return jresult;
78876 }
78877
78878
78879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
78880   void * jresult ;
78881   Dali::Toolkit::FixedRuler *result = 0 ;
78882
78883   {
78884     try {
78885       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
78886     } catch (std::out_of_range& e) {
78887       {
78888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78889       };
78890     } catch (std::exception& e) {
78891       {
78892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78893       };
78894     } catch (Dali::DaliException e) {
78895       {
78896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78897       };
78898     } catch (...) {
78899       {
78900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78901       };
78902     }
78903   }
78904
78905   jresult = (void *)result;
78906   return jresult;
78907 }
78908
78909
78910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78911   float jresult ;
78912   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78913   float arg2 ;
78914   float arg3 ;
78915   float result;
78916
78917   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78918   arg2 = (float)jarg2;
78919   arg3 = (float)jarg3;
78920   {
78921     try {
78922       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
78923     } catch (std::out_of_range& e) {
78924       {
78925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78926       };
78927     } catch (std::exception& e) {
78928       {
78929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78930       };
78931     } catch (Dali::DaliException e) {
78932       {
78933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78934       };
78935     } catch (...) {
78936       {
78937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78938       };
78939     }
78940   }
78941
78942   jresult = result;
78943   return jresult;
78944 }
78945
78946
78947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78948   float jresult ;
78949   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78950   unsigned int arg2 ;
78951   unsigned int *arg3 = 0 ;
78952   bool arg4 ;
78953   float result;
78954
78955   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78956   arg2 = (unsigned int)jarg2;
78957   arg3 = (unsigned int *)jarg3;
78958   arg4 = jarg4 ? true : false;
78959   {
78960     try {
78961       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78962     } catch (std::out_of_range& e) {
78963       {
78964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78965       };
78966     } catch (std::exception& e) {
78967       {
78968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78969       };
78970     } catch (Dali::DaliException e) {
78971       {
78972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78973       };
78974     } catch (...) {
78975       {
78976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78977       };
78978     }
78979   }
78980
78981   jresult = result;
78982   return jresult;
78983 }
78984
78985
78986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78987   unsigned int jresult ;
78988   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78989   float arg2 ;
78990   bool arg3 ;
78991   unsigned int result;
78992
78993   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78994   arg2 = (float)jarg2;
78995   arg3 = jarg3 ? true : false;
78996   {
78997     try {
78998       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78999     } catch (std::out_of_range& e) {
79000       {
79001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79002       };
79003     } catch (std::exception& e) {
79004       {
79005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79006       };
79007     } catch (Dali::DaliException e) {
79008       {
79009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79010       };
79011     } catch (...) {
79012       {
79013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79014       };
79015     }
79016   }
79017
79018   jresult = result;
79019   return jresult;
79020 }
79021
79022
79023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79024   unsigned int jresult ;
79025   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79026   unsigned int result;
79027
79028   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79029   {
79030     try {
79031       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79032     } catch (std::out_of_range& e) {
79033       {
79034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79035       };
79036     } catch (std::exception& e) {
79037       {
79038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79039       };
79040     } catch (Dali::DaliException e) {
79041       {
79042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79043       };
79044     } catch (...) {
79045       {
79046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79047       };
79048     }
79049   }
79050
79051   jresult = result;
79052   return jresult;
79053 }
79054
79055
79056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79057   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79058
79059   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79060   {
79061     try {
79062       delete arg1;
79063     } catch (std::out_of_range& e) {
79064       {
79065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79066       };
79067     } catch (std::exception& e) {
79068       {
79069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79070       };
79071     } catch (Dali::DaliException e) {
79072       {
79073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79074       };
79075     } catch (...) {
79076       {
79077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79078       };
79079     }
79080   }
79081
79082 }
79083
79084
79085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79086   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79087   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79088
79089   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79090   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79091   if (arg1) (arg1)->scale = *arg2;
79092 }
79093
79094
79095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79096   void * jresult ;
79097   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79098   Dali::Toolkit::ClampState2D *result = 0 ;
79099
79100   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79101   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79102   jresult = (void *)result;
79103   return jresult;
79104 }
79105
79106
79107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79108   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79109   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79110
79111   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79112   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79113   if (arg1) (arg1)->position = *arg2;
79114 }
79115
79116
79117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79118   void * jresult ;
79119   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79120   Dali::Toolkit::ClampState2D *result = 0 ;
79121
79122   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79123   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79124   jresult = (void *)result;
79125   return jresult;
79126 }
79127
79128
79129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79130   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79131   Dali::Toolkit::ClampState arg2 ;
79132
79133   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79134   arg2 = (Dali::Toolkit::ClampState)jarg2;
79135   if (arg1) (arg1)->rotation = arg2;
79136 }
79137
79138
79139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79140   int jresult ;
79141   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79142   Dali::Toolkit::ClampState result;
79143
79144   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79145   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79146   jresult = (int)result;
79147   return jresult;
79148 }
79149
79150
79151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79152   void * jresult ;
79153   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79154
79155   {
79156     try {
79157       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79158     } catch (std::out_of_range& e) {
79159       {
79160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79161       };
79162     } catch (std::exception& e) {
79163       {
79164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79165       };
79166     } catch (Dali::DaliException e) {
79167       {
79168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79169       };
79170     } catch (...) {
79171       {
79172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79173       };
79174     }
79175   }
79176
79177   jresult = (void *)result;
79178   return jresult;
79179 }
79180
79181
79182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79183   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79184
79185   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79186   {
79187     try {
79188       delete arg1;
79189     } catch (std::out_of_range& e) {
79190       {
79191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79192       };
79193     } catch (std::exception& e) {
79194       {
79195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79196       };
79197     } catch (Dali::DaliException e) {
79198       {
79199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79200       };
79201     } catch (...) {
79202       {
79203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79204       };
79205     }
79206   }
79207
79208 }
79209
79210
79211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79212   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79213   Dali::Toolkit::SnapType arg2 ;
79214
79215   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79216   arg2 = (Dali::Toolkit::SnapType)jarg2;
79217   if (arg1) (arg1)->type = arg2;
79218 }
79219
79220
79221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79222   int jresult ;
79223   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79224   Dali::Toolkit::SnapType result;
79225
79226   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79227   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79228   jresult = (int)result;
79229   return jresult;
79230 }
79231
79232
79233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79234   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79235   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79236
79237   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79238   arg2 = (Dali::Vector2 *)jarg2;
79239   if (arg1) (arg1)->position = *arg2;
79240 }
79241
79242
79243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79244   void * jresult ;
79245   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79246   Dali::Vector2 *result = 0 ;
79247
79248   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79249   result = (Dali::Vector2 *)& ((arg1)->position);
79250   jresult = (void *)result;
79251   return jresult;
79252 }
79253
79254
79255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79256   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79257   float arg2 ;
79258
79259   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79260   arg2 = (float)jarg2;
79261   if (arg1) (arg1)->duration = arg2;
79262 }
79263
79264
79265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79266   float jresult ;
79267   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79268   float result;
79269
79270   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79271   result = (float) ((arg1)->duration);
79272   jresult = result;
79273   return jresult;
79274 }
79275
79276
79277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79278   void * jresult ;
79279   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79280
79281   {
79282     try {
79283       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79284     } catch (std::out_of_range& e) {
79285       {
79286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79287       };
79288     } catch (std::exception& e) {
79289       {
79290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79291       };
79292     } catch (Dali::DaliException e) {
79293       {
79294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79295       };
79296     } catch (...) {
79297       {
79298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79299       };
79300     }
79301   }
79302
79303   jresult = (void *)result;
79304   return jresult;
79305 }
79306
79307
79308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79309   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79310
79311   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79312   {
79313     try {
79314       delete arg1;
79315     } catch (std::out_of_range& e) {
79316       {
79317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79318       };
79319     } catch (std::exception& e) {
79320       {
79321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79322       };
79323     } catch (Dali::DaliException e) {
79324       {
79325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79326       };
79327     } catch (...) {
79328       {
79329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79330       };
79331     }
79332   }
79333
79334 }
79335
79336
79337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79338   int jresult ;
79339   int result;
79340
79341   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79342   jresult = (int)result;
79343   return jresult;
79344 }
79345
79346
79347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79348   int jresult ;
79349   int result;
79350
79351   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79352   jresult = (int)result;
79353   return jresult;
79354 }
79355
79356
79357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79358   int jresult ;
79359   int result;
79360
79361   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79362   jresult = (int)result;
79363   return jresult;
79364 }
79365
79366
79367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79368   int jresult ;
79369   int result;
79370
79371   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79372   jresult = (int)result;
79373   return jresult;
79374 }
79375
79376
79377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79378   int jresult ;
79379   int result;
79380
79381   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79382   jresult = (int)result;
79383   return jresult;
79384 }
79385
79386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79387   int jresult ;
79388   int result;
79389
79390   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79391   jresult = (int)result;
79392   return jresult;
79393 }
79394
79395
79396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79397   int jresult ;
79398   int result;
79399
79400   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79401   jresult = (int)result;
79402   return jresult;
79403 }
79404
79405
79406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79407   int jresult ;
79408   int result;
79409
79410   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79411   jresult = (int)result;
79412   return jresult;
79413 }
79414
79415
79416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79417   int jresult ;
79418   int result;
79419
79420   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79421   jresult = (int)result;
79422   return jresult;
79423 }
79424
79425
79426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79427   int jresult ;
79428   int result;
79429
79430   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79431   jresult = (int)result;
79432   return jresult;
79433 }
79434
79435
79436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79437   int jresult ;
79438   int result;
79439
79440   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79441   jresult = (int)result;
79442   return jresult;
79443 }
79444
79445
79446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79447   int jresult ;
79448   int result;
79449
79450   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79451   jresult = (int)result;
79452   return jresult;
79453 }
79454
79455
79456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79457   int jresult ;
79458   int result;
79459
79460   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79461   jresult = (int)result;
79462   return jresult;
79463 }
79464
79465
79466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79467   int jresult ;
79468   int result;
79469
79470   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79471   jresult = (int)result;
79472   return jresult;
79473 }
79474
79475
79476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79477   int jresult ;
79478   int result;
79479
79480   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79481   jresult = (int)result;
79482   return jresult;
79483 }
79484
79485
79486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79487   int jresult ;
79488   int result;
79489
79490   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79491   jresult = (int)result;
79492   return jresult;
79493 }
79494
79495
79496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79497   int jresult ;
79498   int result;
79499
79500   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79501   jresult = (int)result;
79502   return jresult;
79503 }
79504
79505
79506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79507   int jresult ;
79508   int result;
79509
79510   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79511   jresult = (int)result;
79512   return jresult;
79513 }
79514
79515
79516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79517   int jresult ;
79518   int result;
79519
79520   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79521   jresult = (int)result;
79522   return jresult;
79523 }
79524
79525
79526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79527   int jresult ;
79528   int result;
79529
79530   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79531   jresult = (int)result;
79532   return jresult;
79533 }
79534
79535
79536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79537   int jresult ;
79538   int result;
79539
79540   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79541   jresult = (int)result;
79542   return jresult;
79543 }
79544
79545
79546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79547   int jresult ;
79548   int result;
79549
79550   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79551   jresult = (int)result;
79552   return jresult;
79553 }
79554
79555
79556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79557   int jresult ;
79558   int result;
79559
79560   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79561   jresult = (int)result;
79562   return jresult;
79563 }
79564
79565
79566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79567   int jresult ;
79568   int result;
79569
79570   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79571   jresult = (int)result;
79572   return jresult;
79573 }
79574
79575
79576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79577   int jresult ;
79578   int result;
79579
79580   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79581   jresult = (int)result;
79582   return jresult;
79583 }
79584
79585
79586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79587   int jresult ;
79588   int result;
79589
79590   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79591   jresult = (int)result;
79592   return jresult;
79593 }
79594
79595
79596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79597   void * jresult ;
79598   Dali::Toolkit::ScrollView::Property *result = 0 ;
79599
79600   {
79601     try {
79602       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79603     } catch (std::out_of_range& e) {
79604       {
79605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79606       };
79607     } catch (std::exception& e) {
79608       {
79609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79610       };
79611     } catch (Dali::DaliException e) {
79612       {
79613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79614       };
79615     } catch (...) {
79616       {
79617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79618       };
79619     }
79620   }
79621
79622   jresult = (void *)result;
79623   return jresult;
79624 }
79625
79626
79627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79628   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79629
79630   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79631   {
79632     try {
79633       delete arg1;
79634     } catch (std::out_of_range& e) {
79635       {
79636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79637       };
79638     } catch (std::exception& e) {
79639       {
79640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79641       };
79642     } catch (Dali::DaliException e) {
79643       {
79644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79645       };
79646     } catch (...) {
79647       {
79648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79649       };
79650     }
79651   }
79652
79653 }
79654
79655
79656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79657   void * jresult ;
79658   Dali::Toolkit::ScrollView *result = 0 ;
79659
79660   {
79661     try {
79662       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79663     } catch (std::out_of_range& e) {
79664       {
79665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79666       };
79667     } catch (std::exception& e) {
79668       {
79669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79670       };
79671     } catch (Dali::DaliException e) {
79672       {
79673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79674       };
79675     } catch (...) {
79676       {
79677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79678       };
79679     }
79680   }
79681
79682   jresult = (void *)result;
79683   return jresult;
79684 }
79685
79686
79687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79688   void * jresult ;
79689   Dali::Toolkit::ScrollView *arg1 = 0 ;
79690   Dali::Toolkit::ScrollView *result = 0 ;
79691
79692   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79693   if (!arg1) {
79694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79695     return 0;
79696   }
79697   {
79698     try {
79699       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79700     } catch (std::out_of_range& e) {
79701       {
79702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79703       };
79704     } catch (std::exception& e) {
79705       {
79706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79707       };
79708     } catch (Dali::DaliException e) {
79709       {
79710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79711       };
79712     } catch (...) {
79713       {
79714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79715       };
79716     }
79717   }
79718
79719   jresult = (void *)result;
79720   return jresult;
79721 }
79722
79723
79724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79725   void * jresult ;
79726   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79727   Dali::Toolkit::ScrollView *arg2 = 0 ;
79728   Dali::Toolkit::ScrollView *result = 0 ;
79729
79730   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79731   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79732   if (!arg2) {
79733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79734     return 0;
79735   }
79736   {
79737     try {
79738       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79739     } catch (std::out_of_range& e) {
79740       {
79741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79742       };
79743     } catch (std::exception& e) {
79744       {
79745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79746       };
79747     } catch (Dali::DaliException e) {
79748       {
79749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79750       };
79751     } catch (...) {
79752       {
79753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79754       };
79755     }
79756   }
79757
79758   jresult = (void *)result;
79759   return jresult;
79760 }
79761
79762
79763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79764   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79765
79766   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79767   {
79768     try {
79769       delete arg1;
79770     } catch (std::out_of_range& e) {
79771       {
79772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79773       };
79774     } catch (std::exception& e) {
79775       {
79776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79777       };
79778     } catch (Dali::DaliException e) {
79779       {
79780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79781       };
79782     } catch (...) {
79783       {
79784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79785       };
79786     }
79787   }
79788
79789 }
79790
79791
79792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
79793   void * jresult ;
79794   Dali::Toolkit::ScrollView result;
79795
79796   {
79797     try {
79798       result = Dali::Toolkit::ScrollView::New();
79799     } catch (std::out_of_range& e) {
79800       {
79801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79802       };
79803     } catch (std::exception& e) {
79804       {
79805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79806       };
79807     } catch (Dali::DaliException e) {
79808       {
79809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79810       };
79811     } catch (...) {
79812       {
79813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79814       };
79815     }
79816   }
79817
79818   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79819   return jresult;
79820 }
79821
79822
79823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
79824   void * jresult ;
79825   Dali::BaseHandle arg1 ;
79826   Dali::BaseHandle *argp1 ;
79827   Dali::Toolkit::ScrollView result;
79828
79829   argp1 = (Dali::BaseHandle *)jarg1;
79830   if (!argp1) {
79831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79832     return 0;
79833   }
79834   arg1 = *argp1;
79835   {
79836     try {
79837       result = Dali::Toolkit::ScrollView::DownCast(arg1);
79838     } catch (std::out_of_range& e) {
79839       {
79840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79841       };
79842     } catch (std::exception& e) {
79843       {
79844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79845       };
79846     } catch (Dali::DaliException e) {
79847       {
79848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79849       };
79850     } catch (...) {
79851       {
79852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79853       };
79854     }
79855   }
79856
79857   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79858   return jresult;
79859 }
79860
79861
79862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
79863   void * jresult ;
79864   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79865   Dali::AlphaFunction result;
79866
79867   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79868   {
79869     try {
79870       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
79871     } catch (std::out_of_range& e) {
79872       {
79873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79874       };
79875     } catch (std::exception& e) {
79876       {
79877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79878       };
79879     } catch (Dali::DaliException e) {
79880       {
79881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79882       };
79883     } catch (...) {
79884       {
79885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79886       };
79887     }
79888   }
79889
79890   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79891   return jresult;
79892 }
79893
79894
79895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
79896   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79897   Dali::AlphaFunction arg2 ;
79898   Dali::AlphaFunction *argp2 ;
79899
79900   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79901   argp2 = (Dali::AlphaFunction *)jarg2;
79902   if (!argp2) {
79903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79904     return ;
79905   }
79906   arg2 = *argp2;
79907   {
79908     try {
79909       (arg1)->SetScrollSnapAlphaFunction(arg2);
79910     } catch (std::out_of_range& e) {
79911       {
79912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79913       };
79914     } catch (std::exception& e) {
79915       {
79916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79917       };
79918     } catch (Dali::DaliException e) {
79919       {
79920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79921       };
79922     } catch (...) {
79923       {
79924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79925       };
79926     }
79927   }
79928
79929 }
79930
79931
79932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
79933   void * jresult ;
79934   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79935   Dali::AlphaFunction result;
79936
79937   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79938   {
79939     try {
79940       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79941     } catch (std::out_of_range& e) {
79942       {
79943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79944       };
79945     } catch (std::exception& e) {
79946       {
79947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79948       };
79949     } catch (Dali::DaliException e) {
79950       {
79951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79952       };
79953     } catch (...) {
79954       {
79955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79956       };
79957     }
79958   }
79959
79960   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79961   return jresult;
79962 }
79963
79964
79965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79966   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79967   Dali::AlphaFunction arg2 ;
79968   Dali::AlphaFunction *argp2 ;
79969
79970   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79971   argp2 = (Dali::AlphaFunction *)jarg2;
79972   if (!argp2) {
79973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79974     return ;
79975   }
79976   arg2 = *argp2;
79977   {
79978     try {
79979       (arg1)->SetScrollFlickAlphaFunction(arg2);
79980     } catch (std::out_of_range& e) {
79981       {
79982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79983       };
79984     } catch (std::exception& e) {
79985       {
79986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79987       };
79988     } catch (Dali::DaliException e) {
79989       {
79990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79991       };
79992     } catch (...) {
79993       {
79994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79995       };
79996     }
79997   }
79998
79999 }
80000
80001
80002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80003   float jresult ;
80004   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80005   float result;
80006
80007   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80008   {
80009     try {
80010       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80011     } catch (std::out_of_range& e) {
80012       {
80013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80014       };
80015     } catch (std::exception& e) {
80016       {
80017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80018       };
80019     } catch (Dali::DaliException e) {
80020       {
80021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80022       };
80023     } catch (...) {
80024       {
80025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80026       };
80027     }
80028   }
80029
80030   jresult = result;
80031   return jresult;
80032 }
80033
80034
80035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80036   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80037   float arg2 ;
80038
80039   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80040   arg2 = (float)jarg2;
80041   {
80042     try {
80043       (arg1)->SetScrollSnapDuration(arg2);
80044     } catch (std::out_of_range& e) {
80045       {
80046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80047       };
80048     } catch (std::exception& e) {
80049       {
80050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80051       };
80052     } catch (Dali::DaliException e) {
80053       {
80054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80055       };
80056     } catch (...) {
80057       {
80058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80059       };
80060     }
80061   }
80062
80063 }
80064
80065
80066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80067   float jresult ;
80068   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80069   float result;
80070
80071   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80072   {
80073     try {
80074       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80075     } catch (std::out_of_range& e) {
80076       {
80077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80078       };
80079     } catch (std::exception& e) {
80080       {
80081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80082       };
80083     } catch (Dali::DaliException e) {
80084       {
80085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80086       };
80087     } catch (...) {
80088       {
80089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80090       };
80091     }
80092   }
80093
80094   jresult = result;
80095   return jresult;
80096 }
80097
80098
80099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80100   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80101   float arg2 ;
80102
80103   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80104   arg2 = (float)jarg2;
80105   {
80106     try {
80107       (arg1)->SetScrollFlickDuration(arg2);
80108     } catch (std::out_of_range& e) {
80109       {
80110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80111       };
80112     } catch (std::exception& e) {
80113       {
80114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80115       };
80116     } catch (Dali::DaliException e) {
80117       {
80118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80119       };
80120     } catch (...) {
80121       {
80122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80123       };
80124     }
80125   }
80126
80127 }
80128
80129
80130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80131   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80132   Dali::Toolkit::RulerPtr arg2 ;
80133   Dali::Toolkit::RulerPtr *argp2 ;
80134
80135   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80136   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80137   if (!argp2) {
80138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80139     return ;
80140   }
80141   arg2 = *argp2;
80142   {
80143     try {
80144       (arg1)->SetRulerX(arg2);
80145     } catch (std::out_of_range& e) {
80146       {
80147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80148       };
80149     } catch (std::exception& e) {
80150       {
80151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80152       };
80153     } catch (Dali::DaliException e) {
80154       {
80155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80156       };
80157     } catch (...) {
80158       {
80159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80160       };
80161     }
80162   }
80163
80164 }
80165
80166
80167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80168   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80169   Dali::Toolkit::RulerPtr arg2 ;
80170   Dali::Toolkit::RulerPtr *argp2 ;
80171
80172   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80173   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80174   if (!argp2) {
80175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80176     return ;
80177   }
80178   arg2 = *argp2;
80179   {
80180     try {
80181       (arg1)->SetRulerY(arg2);
80182     } catch (std::out_of_range& e) {
80183       {
80184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80185       };
80186     } catch (std::exception& e) {
80187       {
80188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80189       };
80190     } catch (Dali::DaliException e) {
80191       {
80192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80193       };
80194     } catch (...) {
80195       {
80196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80197       };
80198     }
80199   }
80200
80201 }
80202
80203
80204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80205   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80206   bool arg2 ;
80207
80208   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80209   arg2 = jarg2 ? true : false;
80210   {
80211     try {
80212       (arg1)->SetScrollSensitive(arg2);
80213     } catch (std::out_of_range& e) {
80214       {
80215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80216       };
80217     } catch (std::exception& e) {
80218       {
80219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80220       };
80221     } catch (Dali::DaliException e) {
80222       {
80223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80224       };
80225     } catch (...) {
80226       {
80227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80228       };
80229     }
80230   }
80231
80232 }
80233
80234
80235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80236   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80237   float arg2 ;
80238   float arg3 ;
80239
80240   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80241   arg2 = (float)jarg2;
80242   arg3 = (float)jarg3;
80243   {
80244     try {
80245       (arg1)->SetMaxOvershoot(arg2,arg3);
80246     } catch (std::out_of_range& e) {
80247       {
80248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80249       };
80250     } catch (std::exception& e) {
80251       {
80252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80253       };
80254     } catch (Dali::DaliException e) {
80255       {
80256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80257       };
80258     } catch (...) {
80259       {
80260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80261       };
80262     }
80263   }
80264
80265 }
80266
80267
80268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80269   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80270   Dali::AlphaFunction arg2 ;
80271   Dali::AlphaFunction *argp2 ;
80272
80273   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80274   argp2 = (Dali::AlphaFunction *)jarg2;
80275   if (!argp2) {
80276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80277     return ;
80278   }
80279   arg2 = *argp2;
80280   {
80281     try {
80282       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80283     } catch (std::out_of_range& e) {
80284       {
80285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80286       };
80287     } catch (std::exception& e) {
80288       {
80289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80290       };
80291     } catch (Dali::DaliException e) {
80292       {
80293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80294       };
80295     } catch (...) {
80296       {
80297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80298       };
80299     }
80300   }
80301
80302 }
80303
80304
80305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80306   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80307   float arg2 ;
80308
80309   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80310   arg2 = (float)jarg2;
80311   {
80312     try {
80313       (arg1)->SetSnapOvershootDuration(arg2);
80314     } catch (std::out_of_range& e) {
80315       {
80316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80317       };
80318     } catch (std::exception& e) {
80319       {
80320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80321       };
80322     } catch (Dali::DaliException e) {
80323       {
80324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80325       };
80326     } catch (...) {
80327       {
80328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80329       };
80330     }
80331   }
80332
80333 }
80334
80335
80336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80337   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80338   bool arg2 ;
80339
80340   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80341   arg2 = jarg2 ? true : false;
80342   {
80343     try {
80344       (arg1)->SetActorAutoSnap(arg2);
80345     } catch (std::out_of_range& e) {
80346       {
80347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80348       };
80349     } catch (std::exception& e) {
80350       {
80351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80352       };
80353     } catch (Dali::DaliException e) {
80354       {
80355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80356       };
80357     } catch (...) {
80358       {
80359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80360       };
80361     }
80362   }
80363
80364 }
80365
80366
80367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80368   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80369   bool arg2 ;
80370
80371   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80372   arg2 = jarg2 ? true : false;
80373   {
80374     try {
80375       (arg1)->SetWrapMode(arg2);
80376     } catch (std::out_of_range& e) {
80377       {
80378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80379       };
80380     } catch (std::exception& e) {
80381       {
80382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80383       };
80384     } catch (Dali::DaliException e) {
80385       {
80386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80387       };
80388     } catch (...) {
80389       {
80390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80391       };
80392     }
80393   }
80394
80395 }
80396
80397
80398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80399   int jresult ;
80400   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80401   int result;
80402
80403   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80404   {
80405     try {
80406       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80407     } catch (std::out_of_range& e) {
80408       {
80409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80410       };
80411     } catch (std::exception& e) {
80412       {
80413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80414       };
80415     } catch (Dali::DaliException e) {
80416       {
80417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80418       };
80419     } catch (...) {
80420       {
80421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80422       };
80423     }
80424   }
80425
80426   jresult = result;
80427   return jresult;
80428 }
80429
80430
80431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80432   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80433   int arg2 ;
80434
80435   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80436   arg2 = (int)jarg2;
80437   {
80438     try {
80439       (arg1)->SetScrollUpdateDistance(arg2);
80440     } catch (std::out_of_range& e) {
80441       {
80442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80443       };
80444     } catch (std::exception& e) {
80445       {
80446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80447       };
80448     } catch (Dali::DaliException e) {
80449       {
80450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80451       };
80452     } catch (...) {
80453       {
80454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80455       };
80456     }
80457   }
80458
80459 }
80460
80461
80462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80463   unsigned int jresult ;
80464   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80465   bool result;
80466
80467   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80468   {
80469     try {
80470       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80471     } catch (std::out_of_range& e) {
80472       {
80473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80474       };
80475     } catch (std::exception& e) {
80476       {
80477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80478       };
80479     } catch (Dali::DaliException e) {
80480       {
80481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80482       };
80483     } catch (...) {
80484       {
80485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80486       };
80487     }
80488   }
80489
80490   jresult = result;
80491   return jresult;
80492 }
80493
80494
80495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80496   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80497   bool arg2 ;
80498
80499   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80500   arg2 = jarg2 ? true : false;
80501   {
80502     try {
80503       (arg1)->SetAxisAutoLock(arg2);
80504     } catch (std::out_of_range& e) {
80505       {
80506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80507       };
80508     } catch (std::exception& e) {
80509       {
80510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80511       };
80512     } catch (Dali::DaliException e) {
80513       {
80514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80515       };
80516     } catch (...) {
80517       {
80518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80519       };
80520     }
80521   }
80522
80523 }
80524
80525
80526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80527   float jresult ;
80528   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80529   float result;
80530
80531   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80532   {
80533     try {
80534       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80535     } catch (std::out_of_range& e) {
80536       {
80537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80538       };
80539     } catch (std::exception& e) {
80540       {
80541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80542       };
80543     } catch (Dali::DaliException e) {
80544       {
80545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80546       };
80547     } catch (...) {
80548       {
80549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80550       };
80551     }
80552   }
80553
80554   jresult = result;
80555   return jresult;
80556 }
80557
80558
80559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80560   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80561   float arg2 ;
80562
80563   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80564   arg2 = (float)jarg2;
80565   {
80566     try {
80567       (arg1)->SetAxisAutoLockGradient(arg2);
80568     } catch (std::out_of_range& e) {
80569       {
80570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80571       };
80572     } catch (std::exception& e) {
80573       {
80574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80575       };
80576     } catch (Dali::DaliException e) {
80577       {
80578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80579       };
80580     } catch (...) {
80581       {
80582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80583       };
80584     }
80585   }
80586
80587 }
80588
80589
80590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80591   float jresult ;
80592   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80593   float result;
80594
80595   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80596   {
80597     try {
80598       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80599     } catch (std::out_of_range& e) {
80600       {
80601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80602       };
80603     } catch (std::exception& e) {
80604       {
80605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80606       };
80607     } catch (Dali::DaliException e) {
80608       {
80609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80610       };
80611     } catch (...) {
80612       {
80613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80614       };
80615     }
80616   }
80617
80618   jresult = result;
80619   return jresult;
80620 }
80621
80622
80623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80624   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80625   float arg2 ;
80626
80627   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80628   arg2 = (float)jarg2;
80629   {
80630     try {
80631       (arg1)->SetFrictionCoefficient(arg2);
80632     } catch (std::out_of_range& e) {
80633       {
80634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80635       };
80636     } catch (std::exception& e) {
80637       {
80638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80639       };
80640     } catch (Dali::DaliException e) {
80641       {
80642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80643       };
80644     } catch (...) {
80645       {
80646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80647       };
80648     }
80649   }
80650
80651 }
80652
80653
80654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80655   float jresult ;
80656   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80657   float result;
80658
80659   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80660   {
80661     try {
80662       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80663     } catch (std::out_of_range& e) {
80664       {
80665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80666       };
80667     } catch (std::exception& e) {
80668       {
80669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80670       };
80671     } catch (Dali::DaliException e) {
80672       {
80673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80674       };
80675     } catch (...) {
80676       {
80677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80678       };
80679     }
80680   }
80681
80682   jresult = result;
80683   return jresult;
80684 }
80685
80686
80687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80688   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80689   float arg2 ;
80690
80691   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80692   arg2 = (float)jarg2;
80693   {
80694     try {
80695       (arg1)->SetFlickSpeedCoefficient(arg2);
80696     } catch (std::out_of_range& e) {
80697       {
80698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80699       };
80700     } catch (std::exception& e) {
80701       {
80702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80703       };
80704     } catch (Dali::DaliException e) {
80705       {
80706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80707       };
80708     } catch (...) {
80709       {
80710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80711       };
80712     }
80713   }
80714
80715 }
80716
80717
80718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80719   void * jresult ;
80720   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80721   Dali::Vector2 result;
80722
80723   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80724   {
80725     try {
80726       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80727     } catch (std::out_of_range& e) {
80728       {
80729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80730       };
80731     } catch (std::exception& e) {
80732       {
80733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80734       };
80735     } catch (Dali::DaliException e) {
80736       {
80737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80738       };
80739     } catch (...) {
80740       {
80741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80742       };
80743     }
80744   }
80745
80746   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80747   return jresult;
80748 }
80749
80750
80751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80752   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80753   Dali::Vector2 *arg2 = 0 ;
80754
80755   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80756   arg2 = (Dali::Vector2 *)jarg2;
80757   if (!arg2) {
80758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80759     return ;
80760   }
80761   {
80762     try {
80763       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80764     } catch (std::out_of_range& e) {
80765       {
80766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80767       };
80768     } catch (std::exception& e) {
80769       {
80770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80771       };
80772     } catch (Dali::DaliException e) {
80773       {
80774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80775       };
80776     } catch (...) {
80777       {
80778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80779       };
80780     }
80781   }
80782
80783 }
80784
80785
80786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
80787   float jresult ;
80788   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80789   float result;
80790
80791   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80792   {
80793     try {
80794       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
80795     } catch (std::out_of_range& e) {
80796       {
80797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80798       };
80799     } catch (std::exception& e) {
80800       {
80801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80802       };
80803     } catch (Dali::DaliException e) {
80804       {
80805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80806       };
80807     } catch (...) {
80808       {
80809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80810       };
80811     }
80812   }
80813
80814   jresult = result;
80815   return jresult;
80816 }
80817
80818
80819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
80820   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80821   float arg2 ;
80822
80823   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80824   arg2 = (float)jarg2;
80825   {
80826     try {
80827       (arg1)->SetMinimumSpeedForFlick(arg2);
80828     } catch (std::out_of_range& e) {
80829       {
80830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80831       };
80832     } catch (std::exception& e) {
80833       {
80834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80835       };
80836     } catch (Dali::DaliException e) {
80837       {
80838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80839       };
80840     } catch (...) {
80841       {
80842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80843       };
80844     }
80845   }
80846
80847 }
80848
80849
80850 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
80851   float jresult ;
80852   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80853   float result;
80854
80855   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80856   {
80857     try {
80858       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
80859     } catch (std::out_of_range& e) {
80860       {
80861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80862       };
80863     } catch (std::exception& e) {
80864       {
80865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80866       };
80867     } catch (Dali::DaliException e) {
80868       {
80869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80870       };
80871     } catch (...) {
80872       {
80873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80874       };
80875     }
80876   }
80877
80878   jresult = result;
80879   return jresult;
80880 }
80881
80882
80883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
80884   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80885   float arg2 ;
80886
80887   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80888   arg2 = (float)jarg2;
80889   {
80890     try {
80891       (arg1)->SetMaxFlickSpeed(arg2);
80892     } catch (std::out_of_range& e) {
80893       {
80894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80895       };
80896     } catch (std::exception& e) {
80897       {
80898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80899       };
80900     } catch (Dali::DaliException e) {
80901       {
80902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80903       };
80904     } catch (...) {
80905       {
80906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80907       };
80908     }
80909   }
80910
80911 }
80912
80913
80914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
80915   void * jresult ;
80916   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80917   Dali::Vector2 result;
80918
80919   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80920   {
80921     try {
80922       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
80923     } catch (std::out_of_range& e) {
80924       {
80925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80926       };
80927     } catch (std::exception& e) {
80928       {
80929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80930       };
80931     } catch (Dali::DaliException e) {
80932       {
80933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80934       };
80935     } catch (...) {
80936       {
80937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80938       };
80939     }
80940   }
80941
80942   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80943   return jresult;
80944 }
80945
80946
80947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80948   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80949   Dali::Vector2 arg2 ;
80950   Dali::Vector2 *argp2 ;
80951
80952   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80953   argp2 = (Dali::Vector2 *)jarg2;
80954   if (!argp2) {
80955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80956     return ;
80957   }
80958   arg2 = *argp2;
80959   {
80960     try {
80961       (arg1)->SetWheelScrollDistanceStep(arg2);
80962     } catch (std::out_of_range& e) {
80963       {
80964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80965       };
80966     } catch (std::exception& e) {
80967       {
80968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80969       };
80970     } catch (Dali::DaliException e) {
80971       {
80972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80973       };
80974     } catch (...) {
80975       {
80976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80977       };
80978     }
80979   }
80980
80981 }
80982
80983
80984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80985   void * jresult ;
80986   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80987   Dali::Vector2 result;
80988
80989   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80990   {
80991     try {
80992       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80993     } catch (std::out_of_range& e) {
80994       {
80995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80996       };
80997     } catch (std::exception& e) {
80998       {
80999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81000       };
81001     } catch (Dali::DaliException e) {
81002       {
81003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81004       };
81005     } catch (...) {
81006       {
81007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81008       };
81009     }
81010   }
81011
81012   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81013   return jresult;
81014 }
81015
81016
81017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81018   unsigned int jresult ;
81019   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81020   unsigned int result;
81021
81022   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81023   {
81024     try {
81025       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81026     } catch (std::out_of_range& e) {
81027       {
81028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81029       };
81030     } catch (std::exception& e) {
81031       {
81032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81033       };
81034     } catch (Dali::DaliException e) {
81035       {
81036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81037       };
81038     } catch (...) {
81039       {
81040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81041       };
81042     }
81043   }
81044
81045   jresult = result;
81046   return jresult;
81047 }
81048
81049
81050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81051   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81052   Dali::Vector2 *arg2 = 0 ;
81053
81054   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81055   arg2 = (Dali::Vector2 *)jarg2;
81056   if (!arg2) {
81057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81058     return ;
81059   }
81060   {
81061     try {
81062       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81063     } catch (std::out_of_range& e) {
81064       {
81065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81066       };
81067     } catch (std::exception& e) {
81068       {
81069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81070       };
81071     } catch (Dali::DaliException e) {
81072       {
81073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81074       };
81075     } catch (...) {
81076       {
81077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81078       };
81079     }
81080   }
81081
81082 }
81083
81084
81085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81086   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81087   Dali::Vector2 *arg2 = 0 ;
81088   float arg3 ;
81089
81090   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81091   arg2 = (Dali::Vector2 *)jarg2;
81092   if (!arg2) {
81093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81094     return ;
81095   }
81096   arg3 = (float)jarg3;
81097   {
81098     try {
81099       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81100     } catch (std::out_of_range& e) {
81101       {
81102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81103       };
81104     } catch (std::exception& e) {
81105       {
81106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81107       };
81108     } catch (Dali::DaliException e) {
81109       {
81110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81111       };
81112     } catch (...) {
81113       {
81114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81115       };
81116     }
81117   }
81118
81119 }
81120
81121
81122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81123   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81124   Dali::Vector2 *arg2 = 0 ;
81125   float arg3 ;
81126   Dali::AlphaFunction arg4 ;
81127   Dali::AlphaFunction *argp4 ;
81128
81129   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81130   arg2 = (Dali::Vector2 *)jarg2;
81131   if (!arg2) {
81132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81133     return ;
81134   }
81135   arg3 = (float)jarg3;
81136   argp4 = (Dali::AlphaFunction *)jarg4;
81137   if (!argp4) {
81138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81139     return ;
81140   }
81141   arg4 = *argp4;
81142   {
81143     try {
81144       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81145     } catch (std::out_of_range& e) {
81146       {
81147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81148       };
81149     } catch (std::exception& e) {
81150       {
81151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81152       };
81153     } catch (Dali::DaliException e) {
81154       {
81155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81156       };
81157     } catch (...) {
81158       {
81159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81160       };
81161     }
81162   }
81163
81164 }
81165
81166
81167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81168   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81169   Dali::Vector2 *arg2 = 0 ;
81170   float arg3 ;
81171   Dali::Toolkit::DirectionBias arg4 ;
81172   Dali::Toolkit::DirectionBias arg5 ;
81173
81174   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81175   arg2 = (Dali::Vector2 *)jarg2;
81176   if (!arg2) {
81177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81178     return ;
81179   }
81180   arg3 = (float)jarg3;
81181   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81182   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81183   {
81184     try {
81185       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81186     } catch (std::out_of_range& e) {
81187       {
81188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81189       };
81190     } catch (std::exception& e) {
81191       {
81192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81193       };
81194     } catch (Dali::DaliException e) {
81195       {
81196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81197       };
81198     } catch (...) {
81199       {
81200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81201       };
81202     }
81203   }
81204
81205 }
81206
81207
81208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81209   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81210   Dali::Vector2 *arg2 = 0 ;
81211   float arg3 ;
81212   Dali::AlphaFunction arg4 ;
81213   Dali::Toolkit::DirectionBias arg5 ;
81214   Dali::Toolkit::DirectionBias arg6 ;
81215   Dali::AlphaFunction *argp4 ;
81216
81217   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81218   arg2 = (Dali::Vector2 *)jarg2;
81219   if (!arg2) {
81220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81221     return ;
81222   }
81223   arg3 = (float)jarg3;
81224   argp4 = (Dali::AlphaFunction *)jarg4;
81225   if (!argp4) {
81226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81227     return ;
81228   }
81229   arg4 = *argp4;
81230   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81231   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81232   {
81233     try {
81234       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81235     } catch (std::out_of_range& e) {
81236       {
81237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81238       };
81239     } catch (std::exception& e) {
81240       {
81241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81242       };
81243     } catch (Dali::DaliException e) {
81244       {
81245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81246       };
81247     } catch (...) {
81248       {
81249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81250       };
81251     }
81252   }
81253
81254 }
81255
81256
81257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81258   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81259   unsigned int arg2 ;
81260
81261   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81262   arg2 = (unsigned int)jarg2;
81263   {
81264     try {
81265       (arg1)->ScrollTo(arg2);
81266     } catch (std::out_of_range& e) {
81267       {
81268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81269       };
81270     } catch (std::exception& e) {
81271       {
81272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81273       };
81274     } catch (Dali::DaliException e) {
81275       {
81276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81277       };
81278     } catch (...) {
81279       {
81280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81281       };
81282     }
81283   }
81284
81285 }
81286
81287
81288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81289   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81290   unsigned int arg2 ;
81291   float arg3 ;
81292
81293   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81294   arg2 = (unsigned int)jarg2;
81295   arg3 = (float)jarg3;
81296   {
81297     try {
81298       (arg1)->ScrollTo(arg2,arg3);
81299     } catch (std::out_of_range& e) {
81300       {
81301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81302       };
81303     } catch (std::exception& e) {
81304       {
81305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81306       };
81307     } catch (Dali::DaliException e) {
81308       {
81309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81310       };
81311     } catch (...) {
81312       {
81313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81314       };
81315     }
81316   }
81317
81318 }
81319
81320
81321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81322   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81323   unsigned int arg2 ;
81324   float arg3 ;
81325   Dali::Toolkit::DirectionBias arg4 ;
81326
81327   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81328   arg2 = (unsigned int)jarg2;
81329   arg3 = (float)jarg3;
81330   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81331   {
81332     try {
81333       (arg1)->ScrollTo(arg2,arg3,arg4);
81334     } catch (std::out_of_range& e) {
81335       {
81336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81337       };
81338     } catch (std::exception& e) {
81339       {
81340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81341       };
81342     } catch (Dali::DaliException e) {
81343       {
81344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81345       };
81346     } catch (...) {
81347       {
81348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81349       };
81350     }
81351   }
81352
81353 }
81354
81355
81356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81357   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81358   Dali::Actor *arg2 = 0 ;
81359
81360   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81361   arg2 = (Dali::Actor *)jarg2;
81362   if (!arg2) {
81363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81364     return ;
81365   }
81366   {
81367     try {
81368       (arg1)->ScrollTo(*arg2);
81369     } catch (std::out_of_range& e) {
81370       {
81371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81372       };
81373     } catch (std::exception& e) {
81374       {
81375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81376       };
81377     } catch (Dali::DaliException e) {
81378       {
81379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81380       };
81381     } catch (...) {
81382       {
81383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81384       };
81385     }
81386   }
81387
81388 }
81389
81390
81391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81392   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81393   Dali::Actor *arg2 = 0 ;
81394   float arg3 ;
81395
81396   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81397   arg2 = (Dali::Actor *)jarg2;
81398   if (!arg2) {
81399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81400     return ;
81401   }
81402   arg3 = (float)jarg3;
81403   {
81404     try {
81405       (arg1)->ScrollTo(*arg2,arg3);
81406     } catch (std::out_of_range& e) {
81407       {
81408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81409       };
81410     } catch (std::exception& e) {
81411       {
81412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81413       };
81414     } catch (Dali::DaliException e) {
81415       {
81416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81417       };
81418     } catch (...) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81421       };
81422     }
81423   }
81424
81425 }
81426
81427
81428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81429   unsigned int jresult ;
81430   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81431   bool result;
81432
81433   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81434   {
81435     try {
81436       result = (bool)(arg1)->ScrollToSnapPoint();
81437     } catch (std::out_of_range& e) {
81438       {
81439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81440       };
81441     } catch (std::exception& e) {
81442       {
81443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81444       };
81445     } catch (Dali::DaliException e) {
81446       {
81447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81448       };
81449     } catch (...) {
81450       {
81451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81452       };
81453     }
81454   }
81455
81456   jresult = result;
81457   return jresult;
81458 }
81459
81460
81461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81462   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81463   Dali::Constraint arg2 ;
81464   Dali::Constraint *argp2 ;
81465
81466   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81467   argp2 = (Dali::Constraint *)jarg2;
81468   if (!argp2) {
81469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81470     return ;
81471   }
81472   arg2 = *argp2;
81473   {
81474     try {
81475       (arg1)->ApplyConstraintToChildren(arg2);
81476     } catch (std::out_of_range& e) {
81477       {
81478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81479       };
81480     } catch (std::exception& e) {
81481       {
81482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81483       };
81484     } catch (Dali::DaliException e) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81487       };
81488     } catch (...) {
81489       {
81490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81491       };
81492     }
81493   }
81494
81495 }
81496
81497
81498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81499   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81500
81501   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81502   {
81503     try {
81504       (arg1)->RemoveConstraintsFromChildren();
81505     } catch (std::out_of_range& e) {
81506       {
81507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81508       };
81509     } catch (std::exception& e) {
81510       {
81511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81512       };
81513     } catch (Dali::DaliException e) {
81514       {
81515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81516       };
81517     } catch (...) {
81518       {
81519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81520       };
81521     }
81522   }
81523
81524 }
81525
81526
81527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81528   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81529   Dali::Toolkit::ScrollViewEffect arg2 ;
81530   Dali::Toolkit::ScrollViewEffect *argp2 ;
81531
81532   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81533   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81534   if (!argp2) {
81535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81536     return ;
81537   }
81538   arg2 = *argp2;
81539   {
81540     try {
81541       (arg1)->ApplyEffect(arg2);
81542     } catch (std::out_of_range& e) {
81543       {
81544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81545       };
81546     } catch (std::exception& e) {
81547       {
81548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81549       };
81550     } catch (Dali::DaliException e) {
81551       {
81552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81553       };
81554     } catch (...) {
81555       {
81556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81557       };
81558     }
81559   }
81560
81561 }
81562
81563
81564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81565   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81566   Dali::Toolkit::ScrollViewEffect arg2 ;
81567   Dali::Toolkit::ScrollViewEffect *argp2 ;
81568
81569   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81570   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81571   if (!argp2) {
81572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81573     return ;
81574   }
81575   arg2 = *argp2;
81576   {
81577     try {
81578       (arg1)->RemoveEffect(arg2);
81579     } catch (std::out_of_range& e) {
81580       {
81581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81582       };
81583     } catch (std::exception& e) {
81584       {
81585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81586       };
81587     } catch (Dali::DaliException e) {
81588       {
81589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81590       };
81591     } catch (...) {
81592       {
81593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81594       };
81595     }
81596   }
81597
81598 }
81599
81600
81601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81602   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81603
81604   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81605   {
81606     try {
81607       (arg1)->RemoveAllEffects();
81608     } catch (std::out_of_range& e) {
81609       {
81610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81611       };
81612     } catch (std::exception& e) {
81613       {
81614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81615       };
81616     } catch (Dali::DaliException e) {
81617       {
81618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81619       };
81620     } catch (...) {
81621       {
81622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81623       };
81624     }
81625   }
81626
81627 }
81628
81629
81630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81631   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81632   Dali::Actor arg2 ;
81633   Dali::Actor *argp2 ;
81634
81635   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81636   argp2 = (Dali::Actor *)jarg2;
81637   if (!argp2) {
81638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81639     return ;
81640   }
81641   arg2 = *argp2;
81642   {
81643     try {
81644       (arg1)->BindActor(arg2);
81645     } catch (std::out_of_range& e) {
81646       {
81647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81648       };
81649     } catch (std::exception& e) {
81650       {
81651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81652       };
81653     } catch (Dali::DaliException e) {
81654       {
81655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81656       };
81657     } catch (...) {
81658       {
81659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81660       };
81661     }
81662   }
81663
81664 }
81665
81666
81667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81668   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81669   Dali::Actor arg2 ;
81670   Dali::Actor *argp2 ;
81671
81672   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81673   argp2 = (Dali::Actor *)jarg2;
81674   if (!argp2) {
81675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81676     return ;
81677   }
81678   arg2 = *argp2;
81679   {
81680     try {
81681       (arg1)->UnbindActor(arg2);
81682     } catch (std::out_of_range& e) {
81683       {
81684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81685       };
81686     } catch (std::exception& e) {
81687       {
81688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81689       };
81690     } catch (Dali::DaliException e) {
81691       {
81692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81693       };
81694     } catch (...) {
81695       {
81696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81697       };
81698     }
81699   }
81700
81701 }
81702
81703
81704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81705   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81706   Dali::Radian arg2 ;
81707   Dali::Radian arg3 ;
81708   Dali::Radian *argp2 ;
81709   Dali::Radian *argp3 ;
81710
81711   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81712   argp2 = (Dali::Radian *)jarg2;
81713   if (!argp2) {
81714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81715     return ;
81716   }
81717   arg2 = *argp2;
81718   argp3 = (Dali::Radian *)jarg3;
81719   if (!argp3) {
81720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81721     return ;
81722   }
81723   arg3 = *argp3;
81724   {
81725     try {
81726       (arg1)->SetScrollingDirection(arg2,arg3);
81727     } catch (std::out_of_range& e) {
81728       {
81729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81730       };
81731     } catch (std::exception& e) {
81732       {
81733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81734       };
81735     } catch (Dali::DaliException e) {
81736       {
81737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81738       };
81739     } catch (...) {
81740       {
81741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81742       };
81743     }
81744   }
81745
81746 }
81747
81748
81749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81750   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81751   Dali::Radian arg2 ;
81752   Dali::Radian *argp2 ;
81753
81754   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81755   argp2 = (Dali::Radian *)jarg2;
81756   if (!argp2) {
81757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81758     return ;
81759   }
81760   arg2 = *argp2;
81761   {
81762     try {
81763       (arg1)->SetScrollingDirection(arg2);
81764     } catch (std::out_of_range& e) {
81765       {
81766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81767       };
81768     } catch (std::exception& e) {
81769       {
81770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81771       };
81772     } catch (Dali::DaliException e) {
81773       {
81774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81775       };
81776     } catch (...) {
81777       {
81778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81779       };
81780     }
81781   }
81782
81783 }
81784
81785
81786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
81787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81788   Dali::Radian arg2 ;
81789   Dali::Radian *argp2 ;
81790
81791   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81792   argp2 = (Dali::Radian *)jarg2;
81793   if (!argp2) {
81794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81795     return ;
81796   }
81797   arg2 = *argp2;
81798   {
81799     try {
81800       (arg1)->RemoveScrollingDirection(arg2);
81801     } catch (std::out_of_range& e) {
81802       {
81803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81804       };
81805     } catch (std::exception& e) {
81806       {
81807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81808       };
81809     } catch (Dali::DaliException e) {
81810       {
81811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81812       };
81813     } catch (...) {
81814       {
81815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81816       };
81817     }
81818   }
81819
81820 }
81821
81822
81823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
81824   void * jresult ;
81825   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81826   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
81827
81828   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81829   {
81830     try {
81831       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
81832     } catch (std::out_of_range& e) {
81833       {
81834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81835       };
81836     } catch (std::exception& e) {
81837       {
81838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81839       };
81840     } catch (Dali::DaliException e) {
81841       {
81842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81843       };
81844     } catch (...) {
81845       {
81846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81847       };
81848     }
81849   }
81850
81851   jresult = (void *)result;
81852   return jresult;
81853 }
81854
81855
81856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
81857   int jresult ;
81858   int result;
81859
81860   result = (int)Dali::Toolkit::TableView::Property::ROWS;
81861   jresult = (int)result;
81862   return jresult;
81863 }
81864
81865
81866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
81867   int jresult ;
81868   int result;
81869
81870   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
81871   jresult = (int)result;
81872   return jresult;
81873 }
81874
81875
81876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
81877   int jresult ;
81878   int result;
81879
81880   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
81881   jresult = (int)result;
81882   return jresult;
81883 }
81884
81885
81886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
81887   int jresult ;
81888   int result;
81889
81890   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
81891   jresult = (int)result;
81892   return jresult;
81893 }
81894
81895
81896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
81897   int jresult ;
81898   int result;
81899
81900   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
81901   jresult = (int)result;
81902   return jresult;
81903 }
81904
81905
81906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
81907   void * jresult ;
81908   Dali::Toolkit::TableView::Property *result = 0 ;
81909
81910   {
81911     try {
81912       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
81913     } catch (std::out_of_range& e) {
81914       {
81915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81916       };
81917     } catch (std::exception& e) {
81918       {
81919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81920       };
81921     } catch (Dali::DaliException e) {
81922       {
81923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81924       };
81925     } catch (...) {
81926       {
81927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81928       };
81929     }
81930   }
81931
81932   jresult = (void *)result;
81933   return jresult;
81934 }
81935
81936
81937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81938   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81939
81940   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81941   {
81942     try {
81943       delete arg1;
81944     } catch (std::out_of_range& e) {
81945       {
81946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81947       };
81948     } catch (std::exception& e) {
81949       {
81950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81951       };
81952     } catch (Dali::DaliException e) {
81953       {
81954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81955       };
81956     } catch (...) {
81957       {
81958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81959       };
81960     }
81961   }
81962
81963 }
81964
81965
81966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81967   int jresult ;
81968   int result;
81969
81970   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81971   jresult = (int)result;
81972   return jresult;
81973 }
81974
81975
81976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81977   int jresult ;
81978   int result;
81979
81980   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81981   jresult = (int)result;
81982   return jresult;
81983 }
81984
81985
81986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81987   int jresult ;
81988   int result;
81989
81990   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81991   jresult = (int)result;
81992   return jresult;
81993 }
81994
81995
81996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81997   int jresult ;
81998   int result;
81999
82000   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82001   jresult = (int)result;
82002   return jresult;
82003 }
82004
82005
82006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82007   int jresult ;
82008   int result;
82009
82010   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82011   jresult = (int)result;
82012   return jresult;
82013 }
82014
82015
82016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82017   void * jresult ;
82018   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82019
82020   {
82021     try {
82022       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82023     } catch (std::out_of_range& e) {
82024       {
82025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82026       };
82027     } catch (std::exception& e) {
82028       {
82029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82030       };
82031     } catch (Dali::DaliException e) {
82032       {
82033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82034       };
82035     } catch (...) {
82036       {
82037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82038       };
82039     }
82040   }
82041
82042   jresult = (void *)result;
82043   return jresult;
82044 }
82045
82046
82047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82048   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82049
82050   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82051   {
82052     try {
82053       delete arg1;
82054     } catch (std::out_of_range& e) {
82055       {
82056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82057       };
82058     } catch (std::exception& e) {
82059       {
82060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82061       };
82062     } catch (Dali::DaliException e) {
82063       {
82064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82065       };
82066     } catch (...) {
82067       {
82068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82069       };
82070     }
82071   }
82072
82073 }
82074
82075
82076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82077   void * jresult ;
82078   unsigned int arg1 ;
82079   unsigned int arg2 ;
82080   unsigned int arg3 ;
82081   unsigned int arg4 ;
82082   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82083
82084   arg1 = (unsigned int)jarg1;
82085   arg2 = (unsigned int)jarg2;
82086   arg3 = (unsigned int)jarg3;
82087   arg4 = (unsigned int)jarg4;
82088   {
82089     try {
82090       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82091     } catch (std::out_of_range& e) {
82092       {
82093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82094       };
82095     } catch (std::exception& e) {
82096       {
82097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82098       };
82099     } catch (Dali::DaliException e) {
82100       {
82101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82102       };
82103     } catch (...) {
82104       {
82105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82106       };
82107     }
82108   }
82109
82110   jresult = (void *)result;
82111   return jresult;
82112 }
82113
82114
82115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82116   void * jresult ;
82117   unsigned int arg1 ;
82118   unsigned int arg2 ;
82119   unsigned int arg3 ;
82120   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82121
82122   arg1 = (unsigned int)jarg1;
82123   arg2 = (unsigned int)jarg2;
82124   arg3 = (unsigned int)jarg3;
82125   {
82126     try {
82127       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82128     } catch (std::out_of_range& e) {
82129       {
82130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82131       };
82132     } catch (std::exception& e) {
82133       {
82134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82135       };
82136     } catch (Dali::DaliException e) {
82137       {
82138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82139       };
82140     } catch (...) {
82141       {
82142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82143       };
82144     }
82145   }
82146
82147   jresult = (void *)result;
82148   return jresult;
82149 }
82150
82151
82152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82153   void * jresult ;
82154   unsigned int arg1 ;
82155   unsigned int arg2 ;
82156   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82157
82158   arg1 = (unsigned int)jarg1;
82159   arg2 = (unsigned int)jarg2;
82160   {
82161     try {
82162       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82163     } catch (std::out_of_range& e) {
82164       {
82165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82166       };
82167     } catch (std::exception& e) {
82168       {
82169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82170       };
82171     } catch (Dali::DaliException e) {
82172       {
82173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82174       };
82175     } catch (...) {
82176       {
82177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82178       };
82179     }
82180   }
82181
82182   jresult = (void *)result;
82183   return jresult;
82184 }
82185
82186
82187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82188   void * jresult ;
82189   unsigned int arg1 ;
82190   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82191
82192   arg1 = (unsigned int)jarg1;
82193   {
82194     try {
82195       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82196     } catch (std::out_of_range& e) {
82197       {
82198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82199       };
82200     } catch (std::exception& e) {
82201       {
82202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82203       };
82204     } catch (Dali::DaliException e) {
82205       {
82206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82207       };
82208     } catch (...) {
82209       {
82210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82211       };
82212     }
82213   }
82214
82215   jresult = (void *)result;
82216   return jresult;
82217 }
82218
82219
82220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82221   void * jresult ;
82222   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82223
82224   {
82225     try {
82226       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82227     } catch (std::out_of_range& e) {
82228       {
82229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82230       };
82231     } catch (std::exception& e) {
82232       {
82233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82234       };
82235     } catch (Dali::DaliException e) {
82236       {
82237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82238       };
82239     } catch (...) {
82240       {
82241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82242       };
82243     }
82244   }
82245
82246   jresult = (void *)result;
82247   return jresult;
82248 }
82249
82250
82251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82252   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82253   unsigned int arg2 ;
82254
82255   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82256   arg2 = (unsigned int)jarg2;
82257   if (arg1) (arg1)->rowIndex = arg2;
82258 }
82259
82260
82261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82262   unsigned int jresult ;
82263   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82264   unsigned int result;
82265
82266   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82267   result = (unsigned int) ((arg1)->rowIndex);
82268   jresult = result;
82269   return jresult;
82270 }
82271
82272
82273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82274   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82275   unsigned int arg2 ;
82276
82277   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82278   arg2 = (unsigned int)jarg2;
82279   if (arg1) (arg1)->columnIndex = arg2;
82280 }
82281
82282
82283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82284   unsigned int jresult ;
82285   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82286   unsigned int result;
82287
82288   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82289   result = (unsigned int) ((arg1)->columnIndex);
82290   jresult = result;
82291   return jresult;
82292 }
82293
82294
82295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82296   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82297   unsigned int arg2 ;
82298
82299   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82300   arg2 = (unsigned int)jarg2;
82301   if (arg1) (arg1)->rowSpan = arg2;
82302 }
82303
82304
82305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82306   unsigned int jresult ;
82307   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82308   unsigned int result;
82309
82310   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82311   result = (unsigned int) ((arg1)->rowSpan);
82312   jresult = result;
82313   return jresult;
82314 }
82315
82316
82317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82318   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82319   unsigned int arg2 ;
82320
82321   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82322   arg2 = (unsigned int)jarg2;
82323   if (arg1) (arg1)->columnSpan = arg2;
82324 }
82325
82326
82327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82328   unsigned int jresult ;
82329   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82330   unsigned int result;
82331
82332   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82333   result = (unsigned int) ((arg1)->columnSpan);
82334   jresult = result;
82335   return jresult;
82336 }
82337
82338
82339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82340   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82341
82342   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82343   {
82344     try {
82345       delete arg1;
82346     } catch (std::out_of_range& e) {
82347       {
82348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82349       };
82350     } catch (std::exception& e) {
82351       {
82352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82353       };
82354     } catch (Dali::DaliException e) {
82355       {
82356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82357       };
82358     } catch (...) {
82359       {
82360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82361       };
82362     }
82363   }
82364
82365 }
82366
82367
82368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82369   void * jresult ;
82370   Dali::Toolkit::TableView *result = 0 ;
82371
82372   {
82373     try {
82374       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82375     } catch (std::out_of_range& e) {
82376       {
82377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82378       };
82379     } catch (std::exception& e) {
82380       {
82381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82382       };
82383     } catch (Dali::DaliException e) {
82384       {
82385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82386       };
82387     } catch (...) {
82388       {
82389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82390       };
82391     }
82392   }
82393
82394   jresult = (void *)result;
82395   return jresult;
82396 }
82397
82398
82399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82400   void * jresult ;
82401   Dali::Toolkit::TableView *arg1 = 0 ;
82402   Dali::Toolkit::TableView *result = 0 ;
82403
82404   arg1 = (Dali::Toolkit::TableView *)jarg1;
82405   if (!arg1) {
82406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82407     return 0;
82408   }
82409   {
82410     try {
82411       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82412     } catch (std::out_of_range& e) {
82413       {
82414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82415       };
82416     } catch (std::exception& e) {
82417       {
82418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82419       };
82420     } catch (Dali::DaliException e) {
82421       {
82422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82423       };
82424     } catch (...) {
82425       {
82426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82427       };
82428     }
82429   }
82430
82431   jresult = (void *)result;
82432   return jresult;
82433 }
82434
82435
82436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82437   void * jresult ;
82438   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82439   Dali::Toolkit::TableView *arg2 = 0 ;
82440   Dali::Toolkit::TableView *result = 0 ;
82441
82442   arg1 = (Dali::Toolkit::TableView *)jarg1;
82443   arg2 = (Dali::Toolkit::TableView *)jarg2;
82444   if (!arg2) {
82445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82446     return 0;
82447   }
82448   {
82449     try {
82450       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82451     } catch (std::out_of_range& e) {
82452       {
82453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82454       };
82455     } catch (std::exception& e) {
82456       {
82457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82458       };
82459     } catch (Dali::DaliException e) {
82460       {
82461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82462       };
82463     } catch (...) {
82464       {
82465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82466       };
82467     }
82468   }
82469
82470   jresult = (void *)result;
82471   return jresult;
82472 }
82473
82474
82475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82476   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82477
82478   arg1 = (Dali::Toolkit::TableView *)jarg1;
82479   {
82480     try {
82481       delete arg1;
82482     } catch (std::out_of_range& e) {
82483       {
82484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82485       };
82486     } catch (std::exception& e) {
82487       {
82488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82489       };
82490     } catch (Dali::DaliException e) {
82491       {
82492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82493       };
82494     } catch (...) {
82495       {
82496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82497       };
82498     }
82499   }
82500
82501 }
82502
82503
82504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82505   void * jresult ;
82506   unsigned int arg1 ;
82507   unsigned int arg2 ;
82508   Dali::Toolkit::TableView result;
82509
82510   arg1 = (unsigned int)jarg1;
82511   arg2 = (unsigned int)jarg2;
82512   {
82513     try {
82514       result = Dali::Toolkit::TableView::New(arg1,arg2);
82515     } catch (std::out_of_range& e) {
82516       {
82517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82518       };
82519     } catch (std::exception& e) {
82520       {
82521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82522       };
82523     } catch (Dali::DaliException e) {
82524       {
82525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82526       };
82527     } catch (...) {
82528       {
82529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82530       };
82531     }
82532   }
82533
82534   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82535   return jresult;
82536 }
82537
82538
82539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82540   void * jresult ;
82541   Dali::BaseHandle arg1 ;
82542   Dali::BaseHandle *argp1 ;
82543   Dali::Toolkit::TableView result;
82544
82545   argp1 = (Dali::BaseHandle *)jarg1;
82546   if (!argp1) {
82547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82548     return 0;
82549   }
82550   arg1 = *argp1;
82551   {
82552     try {
82553       result = Dali::Toolkit::TableView::DownCast(arg1);
82554     } catch (std::out_of_range& e) {
82555       {
82556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82557       };
82558     } catch (std::exception& e) {
82559       {
82560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82561       };
82562     } catch (Dali::DaliException e) {
82563       {
82564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82565       };
82566     } catch (...) {
82567       {
82568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82569       };
82570     }
82571   }
82572
82573   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82574   return jresult;
82575 }
82576
82577
82578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82579   unsigned int jresult ;
82580   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82581   Dali::Actor arg2 ;
82582   Dali::Toolkit::TableView::CellPosition arg3 ;
82583   Dali::Actor *argp2 ;
82584   Dali::Toolkit::TableView::CellPosition *argp3 ;
82585   bool result;
82586
82587   arg1 = (Dali::Toolkit::TableView *)jarg1;
82588   argp2 = (Dali::Actor *)jarg2;
82589   if (!argp2) {
82590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82591     return 0;
82592   }
82593   arg2 = *argp2;
82594   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82595   if (!argp3) {
82596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82597     return 0;
82598   }
82599   arg3 = *argp3;
82600   {
82601     try {
82602       result = (bool)(arg1)->AddChild(arg2,arg3);
82603     } catch (std::out_of_range& e) {
82604       {
82605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82606       };
82607     } catch (std::exception& e) {
82608       {
82609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82610       };
82611     } catch (Dali::DaliException e) {
82612       {
82613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82614       };
82615     } catch (...) {
82616       {
82617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82618       };
82619     }
82620   }
82621
82622   jresult = result;
82623   return jresult;
82624 }
82625
82626
82627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82628   void * jresult ;
82629   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82630   Dali::Toolkit::TableView::CellPosition arg2 ;
82631   Dali::Toolkit::TableView::CellPosition *argp2 ;
82632   Dali::Actor result;
82633
82634   arg1 = (Dali::Toolkit::TableView *)jarg1;
82635   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82636   if (!argp2) {
82637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82638     return 0;
82639   }
82640   arg2 = *argp2;
82641   {
82642     try {
82643       result = (arg1)->GetChildAt(arg2);
82644     } catch (std::out_of_range& e) {
82645       {
82646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82647       };
82648     } catch (std::exception& e) {
82649       {
82650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82651       };
82652     } catch (Dali::DaliException e) {
82653       {
82654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82655       };
82656     } catch (...) {
82657       {
82658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82659       };
82660     }
82661   }
82662
82663   jresult = new Dali::Actor((const Dali::Actor &)result);
82664   return jresult;
82665 }
82666
82667
82668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82669   void * jresult ;
82670   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82671   Dali::Toolkit::TableView::CellPosition arg2 ;
82672   Dali::Toolkit::TableView::CellPosition *argp2 ;
82673   Dali::Actor result;
82674
82675   arg1 = (Dali::Toolkit::TableView *)jarg1;
82676   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82677   if (!argp2) {
82678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82679     return 0;
82680   }
82681   arg2 = *argp2;
82682   {
82683     try {
82684       result = (arg1)->RemoveChildAt(arg2);
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 = new Dali::Actor((const Dali::Actor &)result);
82705   return jresult;
82706 }
82707
82708
82709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82710   unsigned int jresult ;
82711   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82712   Dali::Actor arg2 ;
82713   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82714   Dali::Actor *argp2 ;
82715   bool result;
82716
82717   arg1 = (Dali::Toolkit::TableView *)jarg1;
82718   argp2 = (Dali::Actor *)jarg2;
82719   if (!argp2) {
82720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82721     return 0;
82722   }
82723   arg2 = *argp2;
82724   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82725   if (!arg3) {
82726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82727     return 0;
82728   }
82729   {
82730     try {
82731       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82732     } catch (std::out_of_range& e) {
82733       {
82734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82735       };
82736     } catch (std::exception& e) {
82737       {
82738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82739       };
82740     } catch (Dali::DaliException e) {
82741       {
82742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82743       };
82744     } catch (...) {
82745       {
82746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82747       };
82748     }
82749   }
82750
82751   jresult = result;
82752   return jresult;
82753 }
82754
82755
82756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82757   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82758   unsigned int arg2 ;
82759
82760   arg1 = (Dali::Toolkit::TableView *)jarg1;
82761   arg2 = (unsigned int)jarg2;
82762   {
82763     try {
82764       (arg1)->InsertRow(arg2);
82765     } catch (std::out_of_range& e) {
82766       {
82767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82768       };
82769     } catch (std::exception& e) {
82770       {
82771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82772       };
82773     } catch (Dali::DaliException e) {
82774       {
82775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82776       };
82777     } catch (...) {
82778       {
82779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82780       };
82781     }
82782   }
82783
82784 }
82785
82786
82787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
82788   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82789   unsigned int arg2 ;
82790
82791   arg1 = (Dali::Toolkit::TableView *)jarg1;
82792   arg2 = (unsigned int)jarg2;
82793   {
82794     try {
82795       (arg1)->DeleteRow(arg2);
82796     } catch (std::out_of_range& e) {
82797       {
82798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82799       };
82800     } catch (std::exception& e) {
82801       {
82802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82803       };
82804     } catch (Dali::DaliException e) {
82805       {
82806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82807       };
82808     } catch (...) {
82809       {
82810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82811       };
82812     }
82813   }
82814
82815 }
82816
82817
82818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82819   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82820   unsigned int arg2 ;
82821   std::vector< Dali::Actor > *arg3 = 0 ;
82822
82823   arg1 = (Dali::Toolkit::TableView *)jarg1;
82824   arg2 = (unsigned int)jarg2;
82825   arg3 = (std::vector< Dali::Actor > *)jarg3;
82826   if (!arg3) {
82827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82828     return ;
82829   }
82830   {
82831     try {
82832       (arg1)->DeleteRow(arg2,*arg3);
82833     } catch (std::out_of_range& e) {
82834       {
82835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82836       };
82837     } catch (std::exception& e) {
82838       {
82839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82840       };
82841     } catch (Dali::DaliException e) {
82842       {
82843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82844       };
82845     } catch (...) {
82846       {
82847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82848       };
82849     }
82850   }
82851
82852 }
82853
82854
82855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
82856   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82857   unsigned int arg2 ;
82858
82859   arg1 = (Dali::Toolkit::TableView *)jarg1;
82860   arg2 = (unsigned int)jarg2;
82861   {
82862     try {
82863       (arg1)->InsertColumn(arg2);
82864     } catch (std::out_of_range& e) {
82865       {
82866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82867       };
82868     } catch (std::exception& e) {
82869       {
82870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82871       };
82872     } catch (Dali::DaliException e) {
82873       {
82874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82875       };
82876     } catch (...) {
82877       {
82878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82879       };
82880     }
82881   }
82882
82883 }
82884
82885
82886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
82887   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82888   unsigned int arg2 ;
82889
82890   arg1 = (Dali::Toolkit::TableView *)jarg1;
82891   arg2 = (unsigned int)jarg2;
82892   {
82893     try {
82894       (arg1)->DeleteColumn(arg2);
82895     } catch (std::out_of_range& e) {
82896       {
82897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82898       };
82899     } catch (std::exception& e) {
82900       {
82901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82902       };
82903     } catch (Dali::DaliException e) {
82904       {
82905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82906       };
82907     } catch (...) {
82908       {
82909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82910       };
82911     }
82912   }
82913
82914 }
82915
82916
82917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82918   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82919   unsigned int arg2 ;
82920   std::vector< Dali::Actor > *arg3 = 0 ;
82921
82922   arg1 = (Dali::Toolkit::TableView *)jarg1;
82923   arg2 = (unsigned int)jarg2;
82924   arg3 = (std::vector< Dali::Actor > *)jarg3;
82925   if (!arg3) {
82926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82927     return ;
82928   }
82929   {
82930     try {
82931       (arg1)->DeleteColumn(arg2,*arg3);
82932     } catch (std::out_of_range& e) {
82933       {
82934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82935       };
82936     } catch (std::exception& e) {
82937       {
82938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82939       };
82940     } catch (Dali::DaliException e) {
82941       {
82942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82943       };
82944     } catch (...) {
82945       {
82946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82947       };
82948     }
82949   }
82950
82951 }
82952
82953
82954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82955   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82956   unsigned int arg2 ;
82957   unsigned int arg3 ;
82958
82959   arg1 = (Dali::Toolkit::TableView *)jarg1;
82960   arg2 = (unsigned int)jarg2;
82961   arg3 = (unsigned int)jarg3;
82962   {
82963     try {
82964       (arg1)->Resize(arg2,arg3);
82965     } catch (std::out_of_range& e) {
82966       {
82967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82968       };
82969     } catch (std::exception& e) {
82970       {
82971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82972       };
82973     } catch (Dali::DaliException e) {
82974       {
82975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82976       };
82977     } catch (...) {
82978       {
82979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82980       };
82981     }
82982   }
82983
82984 }
82985
82986
82987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82988   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82989   unsigned int arg2 ;
82990   unsigned int arg3 ;
82991   std::vector< Dali::Actor > *arg4 = 0 ;
82992
82993   arg1 = (Dali::Toolkit::TableView *)jarg1;
82994   arg2 = (unsigned int)jarg2;
82995   arg3 = (unsigned int)jarg3;
82996   arg4 = (std::vector< Dali::Actor > *)jarg4;
82997   if (!arg4) {
82998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82999     return ;
83000   }
83001   {
83002     try {
83003       (arg1)->Resize(arg2,arg3,*arg4);
83004     } catch (std::out_of_range& e) {
83005       {
83006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83007       };
83008     } catch (std::exception& e) {
83009       {
83010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83011       };
83012     } catch (Dali::DaliException e) {
83013       {
83014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83015       };
83016     } catch (...) {
83017       {
83018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83019       };
83020     }
83021   }
83022
83023 }
83024
83025
83026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83027   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83028   Dali::Size arg2 ;
83029   Dali::Size *argp2 ;
83030
83031   arg1 = (Dali::Toolkit::TableView *)jarg1;
83032   argp2 = (Dali::Size *)jarg2;
83033   if (!argp2) {
83034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83035     return ;
83036   }
83037   arg2 = *argp2;
83038   {
83039     try {
83040       (arg1)->SetCellPadding(arg2);
83041     } catch (std::out_of_range& e) {
83042       {
83043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83044       };
83045     } catch (std::exception& e) {
83046       {
83047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83048       };
83049     } catch (Dali::DaliException e) {
83050       {
83051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83052       };
83053     } catch (...) {
83054       {
83055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83056       };
83057     }
83058   }
83059
83060 }
83061
83062
83063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83064   void * jresult ;
83065   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83066   Dali::Size result;
83067
83068   arg1 = (Dali::Toolkit::TableView *)jarg1;
83069   {
83070     try {
83071       result = (arg1)->GetCellPadding();
83072     } catch (std::out_of_range& e) {
83073       {
83074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83075       };
83076     } catch (std::exception& e) {
83077       {
83078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83079       };
83080     } catch (Dali::DaliException e) {
83081       {
83082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83083       };
83084     } catch (...) {
83085       {
83086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83087       };
83088     }
83089   }
83090
83091   jresult = new Dali::Size((const Dali::Size &)result);
83092   return jresult;
83093 }
83094
83095
83096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83097   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83098   unsigned int arg2 ;
83099
83100   arg1 = (Dali::Toolkit::TableView *)jarg1;
83101   arg2 = (unsigned int)jarg2;
83102   {
83103     try {
83104       (arg1)->SetFitHeight(arg2);
83105     } catch (std::out_of_range& e) {
83106       {
83107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83108       };
83109     } catch (std::exception& e) {
83110       {
83111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83112       };
83113     } catch (Dali::DaliException e) {
83114       {
83115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83116       };
83117     } catch (...) {
83118       {
83119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83120       };
83121     }
83122   }
83123
83124 }
83125
83126
83127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83128   unsigned int jresult ;
83129   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83130   unsigned int arg2 ;
83131   bool result;
83132
83133   arg1 = (Dali::Toolkit::TableView *)jarg1;
83134   arg2 = (unsigned int)jarg2;
83135   {
83136     try {
83137       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83138     } catch (std::out_of_range& e) {
83139       {
83140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83141       };
83142     } catch (std::exception& e) {
83143       {
83144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83145       };
83146     } catch (Dali::DaliException e) {
83147       {
83148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83149       };
83150     } catch (...) {
83151       {
83152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83153       };
83154     }
83155   }
83156
83157   jresult = result;
83158   return jresult;
83159 }
83160
83161
83162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83163   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83164   unsigned int arg2 ;
83165
83166   arg1 = (Dali::Toolkit::TableView *)jarg1;
83167   arg2 = (unsigned int)jarg2;
83168   {
83169     try {
83170       (arg1)->SetFitWidth(arg2);
83171     } catch (std::out_of_range& e) {
83172       {
83173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83174       };
83175     } catch (std::exception& e) {
83176       {
83177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83178       };
83179     } catch (Dali::DaliException e) {
83180       {
83181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83182       };
83183     } catch (...) {
83184       {
83185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83186       };
83187     }
83188   }
83189
83190 }
83191
83192
83193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83194   unsigned int jresult ;
83195   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83196   unsigned int arg2 ;
83197   bool result;
83198
83199   arg1 = (Dali::Toolkit::TableView *)jarg1;
83200   arg2 = (unsigned int)jarg2;
83201   {
83202     try {
83203       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83204     } catch (std::out_of_range& e) {
83205       {
83206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83207       };
83208     } catch (std::exception& e) {
83209       {
83210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83211       };
83212     } catch (Dali::DaliException e) {
83213       {
83214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83215       };
83216     } catch (...) {
83217       {
83218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83219       };
83220     }
83221   }
83222
83223   jresult = result;
83224   return jresult;
83225 }
83226
83227
83228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83229   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83230   unsigned int arg2 ;
83231   float arg3 ;
83232
83233   arg1 = (Dali::Toolkit::TableView *)jarg1;
83234   arg2 = (unsigned int)jarg2;
83235   arg3 = (float)jarg3;
83236   {
83237     try {
83238       (arg1)->SetFixedHeight(arg2,arg3);
83239     } catch (std::out_of_range& e) {
83240       {
83241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83242       };
83243     } catch (std::exception& e) {
83244       {
83245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83246       };
83247     } catch (Dali::DaliException e) {
83248       {
83249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83250       };
83251     } catch (...) {
83252       {
83253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83254       };
83255     }
83256   }
83257
83258 }
83259
83260
83261 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83262   float jresult ;
83263   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83264   unsigned int arg2 ;
83265   float result;
83266
83267   arg1 = (Dali::Toolkit::TableView *)jarg1;
83268   arg2 = (unsigned int)jarg2;
83269   {
83270     try {
83271       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83272     } catch (std::out_of_range& e) {
83273       {
83274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83275       };
83276     } catch (std::exception& e) {
83277       {
83278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83279       };
83280     } catch (Dali::DaliException e) {
83281       {
83282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83283       };
83284     } catch (...) {
83285       {
83286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83287       };
83288     }
83289   }
83290
83291   jresult = result;
83292   return jresult;
83293 }
83294
83295
83296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83297   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83298   unsigned int arg2 ;
83299   float arg3 ;
83300
83301   arg1 = (Dali::Toolkit::TableView *)jarg1;
83302   arg2 = (unsigned int)jarg2;
83303   arg3 = (float)jarg3;
83304   {
83305     try {
83306       (arg1)->SetRelativeHeight(arg2,arg3);
83307     } catch (std::out_of_range& e) {
83308       {
83309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83310       };
83311     } catch (std::exception& e) {
83312       {
83313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83314       };
83315     } catch (Dali::DaliException e) {
83316       {
83317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83318       };
83319     } catch (...) {
83320       {
83321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83322       };
83323     }
83324   }
83325
83326 }
83327
83328
83329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83330   float jresult ;
83331   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83332   unsigned int arg2 ;
83333   float result;
83334
83335   arg1 = (Dali::Toolkit::TableView *)jarg1;
83336   arg2 = (unsigned int)jarg2;
83337   {
83338     try {
83339       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83340     } catch (std::out_of_range& e) {
83341       {
83342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83343       };
83344     } catch (std::exception& e) {
83345       {
83346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83347       };
83348     } catch (Dali::DaliException e) {
83349       {
83350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83351       };
83352     } catch (...) {
83353       {
83354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83355       };
83356     }
83357   }
83358
83359   jresult = result;
83360   return jresult;
83361 }
83362
83363
83364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83365   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83366   unsigned int arg2 ;
83367   float arg3 ;
83368
83369   arg1 = (Dali::Toolkit::TableView *)jarg1;
83370   arg2 = (unsigned int)jarg2;
83371   arg3 = (float)jarg3;
83372   {
83373     try {
83374       (arg1)->SetFixedWidth(arg2,arg3);
83375     } catch (std::out_of_range& e) {
83376       {
83377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83378       };
83379     } catch (std::exception& e) {
83380       {
83381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83382       };
83383     } catch (Dali::DaliException e) {
83384       {
83385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83386       };
83387     } catch (...) {
83388       {
83389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83390       };
83391     }
83392   }
83393
83394 }
83395
83396
83397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83398   float jresult ;
83399   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83400   unsigned int arg2 ;
83401   float result;
83402
83403   arg1 = (Dali::Toolkit::TableView *)jarg1;
83404   arg2 = (unsigned int)jarg2;
83405   {
83406     try {
83407       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83408     } catch (std::out_of_range& e) {
83409       {
83410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83411       };
83412     } catch (std::exception& e) {
83413       {
83414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83415       };
83416     } catch (Dali::DaliException e) {
83417       {
83418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83419       };
83420     } catch (...) {
83421       {
83422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83423       };
83424     }
83425   }
83426
83427   jresult = result;
83428   return jresult;
83429 }
83430
83431
83432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83433   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83434   unsigned int arg2 ;
83435   float arg3 ;
83436
83437   arg1 = (Dali::Toolkit::TableView *)jarg1;
83438   arg2 = (unsigned int)jarg2;
83439   arg3 = (float)jarg3;
83440   {
83441     try {
83442       (arg1)->SetRelativeWidth(arg2,arg3);
83443     } catch (std::out_of_range& e) {
83444       {
83445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83446       };
83447     } catch (std::exception& e) {
83448       {
83449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83450       };
83451     } catch (Dali::DaliException e) {
83452       {
83453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83454       };
83455     } catch (...) {
83456       {
83457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83458       };
83459     }
83460   }
83461
83462 }
83463
83464
83465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83466   float jresult ;
83467   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83468   unsigned int arg2 ;
83469   float result;
83470
83471   arg1 = (Dali::Toolkit::TableView *)jarg1;
83472   arg2 = (unsigned int)jarg2;
83473   {
83474     try {
83475       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83476     } catch (std::out_of_range& e) {
83477       {
83478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83479       };
83480     } catch (std::exception& e) {
83481       {
83482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83483       };
83484     } catch (Dali::DaliException e) {
83485       {
83486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83487       };
83488     } catch (...) {
83489       {
83490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83491       };
83492     }
83493   }
83494
83495   jresult = result;
83496   return jresult;
83497 }
83498
83499
83500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83501   unsigned int jresult ;
83502   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83503   unsigned int result;
83504
83505   arg1 = (Dali::Toolkit::TableView *)jarg1;
83506   {
83507     try {
83508       result = (unsigned int)(arg1)->GetRows();
83509     } catch (std::out_of_range& e) {
83510       {
83511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83512       };
83513     } catch (std::exception& e) {
83514       {
83515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83516       };
83517     } catch (Dali::DaliException e) {
83518       {
83519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83520       };
83521     } catch (...) {
83522       {
83523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83524       };
83525     }
83526   }
83527
83528   jresult = result;
83529   return jresult;
83530 }
83531
83532
83533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83534   unsigned int jresult ;
83535   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83536   unsigned int result;
83537
83538   arg1 = (Dali::Toolkit::TableView *)jarg1;
83539   {
83540     try {
83541       result = (unsigned int)(arg1)->GetColumns();
83542     } catch (std::out_of_range& e) {
83543       {
83544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83545       };
83546     } catch (std::exception& e) {
83547       {
83548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83549       };
83550     } catch (Dali::DaliException e) {
83551       {
83552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83553       };
83554     } catch (...) {
83555       {
83556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83557       };
83558     }
83559   }
83560
83561   jresult = result;
83562   return jresult;
83563 }
83564
83565
83566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83567   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83568   Dali::Toolkit::TableView::CellPosition arg2 ;
83569   Dali::HorizontalAlignment::Type arg3 ;
83570   Dali::VerticalAlignment::Type arg4 ;
83571   Dali::Toolkit::TableView::CellPosition *argp2 ;
83572
83573   arg1 = (Dali::Toolkit::TableView *)jarg1;
83574   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83575   if (!argp2) {
83576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83577     return ;
83578   }
83579   arg2 = *argp2;
83580   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83581   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83582   {
83583     try {
83584       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83585     } catch (std::out_of_range& e) {
83586       {
83587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83588       };
83589     } catch (std::exception& e) {
83590       {
83591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83592       };
83593     } catch (Dali::DaliException e) {
83594       {
83595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83596       };
83597     } catch (...) {
83598       {
83599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83600       };
83601     }
83602   }
83603
83604 }
83605
83606
83607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83608   unsigned int jresult ;
83609   unsigned int result;
83610
83611   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83612   jresult = result;
83613   return jresult;
83614 }
83615
83616
83617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83618   int jresult ;
83619   int result;
83620
83621   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83622   jresult = (int)result;
83623   return jresult;
83624 }
83625
83626
83627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83628   int jresult ;
83629   int result;
83630
83631   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83632   jresult = (int)result;
83633   return jresult;
83634 }
83635
83636
83637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83638   int jresult ;
83639   int result;
83640
83641   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83642   jresult = (int)result;
83643   return jresult;
83644 }
83645
83646
83647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83648   int jresult ;
83649   int result;
83650
83651   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83652   jresult = (int)result;
83653   return jresult;
83654 }
83655
83656
83657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83658   int jresult ;
83659   int result;
83660
83661   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83662   jresult = (int)result;
83663   return jresult;
83664 }
83665
83666
83667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83668   int jresult ;
83669   int result;
83670
83671   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83672   jresult = (int)result;
83673   return jresult;
83674 }
83675
83676
83677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83678   int jresult ;
83679   int result;
83680
83681   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83682   jresult = (int)result;
83683   return jresult;
83684 }
83685
83686
83687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83688   int jresult ;
83689   int result;
83690
83691   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83692   jresult = (int)result;
83693   return jresult;
83694 }
83695
83696
83697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83698   int jresult ;
83699   int result;
83700
83701   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83702   jresult = (int)result;
83703   return jresult;
83704 }
83705
83706
83707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83708   int jresult ;
83709   int result;
83710
83711   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83712   jresult = (int)result;
83713   return jresult;
83714 }
83715
83716
83717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
83718   int jresult ;
83719   int result;
83720
83721   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
83722   jresult = (int)result;
83723   return jresult;
83724 }
83725
83726
83727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
83728   int jresult ;
83729   int result;
83730
83731   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
83732   jresult = (int)result;
83733   return jresult;
83734 }
83735
83736
83737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
83738   int jresult ;
83739   int result;
83740
83741   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
83742   jresult = (int)result;
83743   return jresult;
83744 }
83745
83746
83747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
83748   int jresult ;
83749   int result;
83750
83751   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
83752   jresult = (int)result;
83753   return jresult;
83754 }
83755
83756
83757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
83758   int jresult ;
83759   int result;
83760
83761   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
83762   jresult = (int)result;
83763   return jresult;
83764 }
83765
83766
83767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
83768   int jresult ;
83769   int result;
83770
83771   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
83772   jresult = (int)result;
83773   return jresult;
83774 }
83775
83776
83777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
83778   int jresult ;
83779   int result;
83780
83781   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
83782   jresult = (int)result;
83783   return jresult;
83784 }
83785
83786
83787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
83788   int jresult ;
83789   int result;
83790
83791   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
83792   jresult = (int)result;
83793   return jresult;
83794 }
83795
83796
83797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
83798   int jresult ;
83799   int result;
83800
83801   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
83802   jresult = (int)result;
83803   return jresult;
83804 }
83805
83806
83807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
83808   void * jresult ;
83809   Dali::Toolkit::TextLabel::Property *result = 0 ;
83810
83811   {
83812     try {
83813       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
83814     } catch (std::out_of_range& e) {
83815       {
83816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83817       };
83818     } catch (std::exception& e) {
83819       {
83820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83821       };
83822     } catch (Dali::DaliException e) {
83823       {
83824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83825       };
83826     } catch (...) {
83827       {
83828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83829       };
83830     }
83831   }
83832
83833   jresult = (void *)result;
83834   return jresult;
83835 }
83836
83837
83838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
83839   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
83840
83841   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
83842   {
83843     try {
83844       delete arg1;
83845     } catch (std::out_of_range& e) {
83846       {
83847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83848       };
83849     } catch (std::exception& e) {
83850       {
83851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83852       };
83853     } catch (Dali::DaliException e) {
83854       {
83855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83856       };
83857     } catch (...) {
83858       {
83859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83860       };
83861     }
83862   }
83863
83864 }
83865
83866
83867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
83868   void * jresult ;
83869   Dali::Toolkit::TextLabel result;
83870
83871   {
83872     try {
83873       result = Dali::Toolkit::TextLabel::New();
83874     } catch (std::out_of_range& e) {
83875       {
83876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83877       };
83878     } catch (std::exception& e) {
83879       {
83880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83881       };
83882     } catch (Dali::DaliException e) {
83883       {
83884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83885       };
83886     } catch (...) {
83887       {
83888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83889       };
83890     }
83891   }
83892
83893   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83894   return jresult;
83895 }
83896
83897
83898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
83899   void * jresult ;
83900   std::string *arg1 = 0 ;
83901   Dali::Toolkit::TextLabel result;
83902
83903   if (!jarg1) {
83904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83905     return 0;
83906   }
83907   std::string arg1_str(jarg1);
83908   arg1 = &arg1_str;
83909   {
83910     try {
83911       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
83912     } catch (std::out_of_range& e) {
83913       {
83914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83915       };
83916     } catch (std::exception& e) {
83917       {
83918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83919       };
83920     } catch (Dali::DaliException e) {
83921       {
83922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83923       };
83924     } catch (...) {
83925       {
83926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83927       };
83928     }
83929   }
83930
83931   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83932
83933   //argout typemap for const std::string&
83934
83935   return jresult;
83936 }
83937
83938
83939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83940   void * jresult ;
83941   Dali::Toolkit::TextLabel *result = 0 ;
83942
83943   {
83944     try {
83945       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83946     } catch (std::out_of_range& e) {
83947       {
83948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83949       };
83950     } catch (std::exception& e) {
83951       {
83952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83953       };
83954     } catch (Dali::DaliException e) {
83955       {
83956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83957       };
83958     } catch (...) {
83959       {
83960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83961       };
83962     }
83963   }
83964
83965   jresult = (void *)result;
83966   return jresult;
83967 }
83968
83969
83970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83971   void * jresult ;
83972   Dali::Toolkit::TextLabel *arg1 = 0 ;
83973   Dali::Toolkit::TextLabel *result = 0 ;
83974
83975   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83976   if (!arg1) {
83977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83978     return 0;
83979   }
83980   {
83981     try {
83982       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83983     } catch (std::out_of_range& e) {
83984       {
83985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83986       };
83987     } catch (std::exception& e) {
83988       {
83989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83990       };
83991     } catch (Dali::DaliException e) {
83992       {
83993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83994       };
83995     } catch (...) {
83996       {
83997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83998       };
83999     }
84000   }
84001
84002   jresult = (void *)result;
84003   return jresult;
84004 }
84005
84006
84007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84008   void * jresult ;
84009   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84010   Dali::Toolkit::TextLabel *arg2 = 0 ;
84011   Dali::Toolkit::TextLabel *result = 0 ;
84012
84013   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84014   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84015   if (!arg2) {
84016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84017     return 0;
84018   }
84019   {
84020     try {
84021       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84022     } catch (std::out_of_range& e) {
84023       {
84024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84025       };
84026     } catch (std::exception& e) {
84027       {
84028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84029       };
84030     } catch (Dali::DaliException e) {
84031       {
84032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84033       };
84034     } catch (...) {
84035       {
84036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84037       };
84038     }
84039   }
84040
84041   jresult = (void *)result;
84042   return jresult;
84043 }
84044
84045
84046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84047   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84048
84049   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84050   {
84051     try {
84052       delete arg1;
84053     } catch (std::out_of_range& e) {
84054       {
84055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84056       };
84057     } catch (std::exception& e) {
84058       {
84059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84060       };
84061     } catch (Dali::DaliException e) {
84062       {
84063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84064       };
84065     } catch (...) {
84066       {
84067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84068       };
84069     }
84070   }
84071
84072 }
84073
84074
84075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84076   void * jresult ;
84077   Dali::BaseHandle arg1 ;
84078   Dali::BaseHandle *argp1 ;
84079   Dali::Toolkit::TextLabel result;
84080
84081   argp1 = (Dali::BaseHandle *)jarg1;
84082   if (!argp1) {
84083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84084     return 0;
84085   }
84086   arg1 = *argp1;
84087   {
84088     try {
84089       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84090     } catch (std::out_of_range& e) {
84091       {
84092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84093       };
84094     } catch (std::exception& e) {
84095       {
84096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84097       };
84098     } catch (Dali::DaliException e) {
84099       {
84100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84101       };
84102     } catch (...) {
84103       {
84104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84105       };
84106     }
84107   }
84108
84109   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84110   return jresult;
84111 }
84112
84113
84114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84115   void * jresult ;
84116   Dali::Toolkit::AccessibilityManager *result = 0 ;
84117
84118   {
84119     try {
84120       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84121     } catch (std::out_of_range& e) {
84122       {
84123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84124       };
84125     } catch (std::exception& e) {
84126       {
84127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84128       };
84129     } catch (Dali::DaliException e) {
84130       {
84131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84132       };
84133     } catch (...) {
84134       {
84135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84136       };
84137     }
84138   }
84139
84140   jresult = (void *)result;
84141   return jresult;
84142 }
84143
84144
84145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84146   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84147
84148   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84149   {
84150     try {
84151       delete arg1;
84152     } catch (std::out_of_range& e) {
84153       {
84154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84155       };
84156     } catch (std::exception& e) {
84157       {
84158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84159       };
84160     } catch (Dali::DaliException e) {
84161       {
84162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84163       };
84164     } catch (...) {
84165       {
84166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84167       };
84168     }
84169   }
84170
84171 }
84172
84173
84174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84175   void * jresult ;
84176   Dali::Toolkit::AccessibilityManager result;
84177
84178   {
84179     try {
84180       result = Dali::Toolkit::AccessibilityManager::Get();
84181     } catch (std::out_of_range& e) {
84182       {
84183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84184       };
84185     } catch (std::exception& e) {
84186       {
84187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84188       };
84189     } catch (Dali::DaliException e) {
84190       {
84191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84192       };
84193     } catch (...) {
84194       {
84195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84196       };
84197     }
84198   }
84199
84200   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84201   return jresult;
84202 }
84203
84204
84205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84206   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84207   Dali::Actor arg2 ;
84208   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84209   std::string *arg4 = 0 ;
84210   Dali::Actor *argp2 ;
84211
84212   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84213   argp2 = (Dali::Actor *)jarg2;
84214   if (!argp2) {
84215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84216     return ;
84217   }
84218   arg2 = *argp2;
84219   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84220   if (!jarg4) {
84221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84222     return ;
84223   }
84224   std::string arg4_str(jarg4);
84225   arg4 = &arg4_str;
84226   {
84227     try {
84228       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84229     } catch (std::out_of_range& e) {
84230       {
84231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84232       };
84233     } catch (std::exception& e) {
84234       {
84235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84236       };
84237     } catch (Dali::DaliException e) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84240       };
84241     } catch (...) {
84242       {
84243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84244       };
84245     }
84246   }
84247
84248
84249   //argout typemap for const std::string&
84250
84251 }
84252
84253
84254 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84255   char * jresult ;
84256   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84257   Dali::Actor arg2 ;
84258   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84259   Dali::Actor *argp2 ;
84260   std::string result;
84261
84262   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84263   argp2 = (Dali::Actor *)jarg2;
84264   if (!argp2) {
84265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84266     return 0;
84267   }
84268   arg2 = *argp2;
84269   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84270   {
84271     try {
84272       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84273     } catch (std::out_of_range& e) {
84274       {
84275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84276       };
84277     } catch (std::exception& e) {
84278       {
84279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84280       };
84281     } catch (Dali::DaliException e) {
84282       {
84283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84284       };
84285     } catch (...) {
84286       {
84287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84288       };
84289     }
84290   }
84291
84292   jresult = SWIG_csharp_string_callback((&result)->c_str());
84293   return jresult;
84294 }
84295
84296
84297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84298   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84299   Dali::Actor arg2 ;
84300   unsigned int arg3 ;
84301   Dali::Actor *argp2 ;
84302
84303   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84304   argp2 = (Dali::Actor *)jarg2;
84305   if (!argp2) {
84306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84307     return ;
84308   }
84309   arg2 = *argp2;
84310   arg3 = (unsigned int)jarg3;
84311   {
84312     try {
84313       (arg1)->SetFocusOrder(arg2,arg3);
84314     } catch (std::out_of_range& e) {
84315       {
84316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84317       };
84318     } catch (std::exception& e) {
84319       {
84320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84321       };
84322     } catch (Dali::DaliException e) {
84323       {
84324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84325       };
84326     } catch (...) {
84327       {
84328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84329       };
84330     }
84331   }
84332
84333 }
84334
84335
84336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84337   unsigned int jresult ;
84338   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84339   Dali::Actor arg2 ;
84340   Dali::Actor *argp2 ;
84341   unsigned int result;
84342
84343   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84344   argp2 = (Dali::Actor *)jarg2;
84345   if (!argp2) {
84346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84347     return 0;
84348   }
84349   arg2 = *argp2;
84350   {
84351     try {
84352       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84353     } catch (std::out_of_range& e) {
84354       {
84355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84356       };
84357     } catch (std::exception& e) {
84358       {
84359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84360       };
84361     } catch (Dali::DaliException e) {
84362       {
84363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84364       };
84365     } catch (...) {
84366       {
84367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84368       };
84369     }
84370   }
84371
84372   jresult = result;
84373   return jresult;
84374 }
84375
84376
84377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84378   unsigned int jresult ;
84379   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84380   unsigned int result;
84381
84382   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84383   {
84384     try {
84385       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84386     } catch (std::out_of_range& e) {
84387       {
84388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84389       };
84390     } catch (std::exception& e) {
84391       {
84392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84393       };
84394     } catch (Dali::DaliException e) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84397       };
84398     } catch (...) {
84399       {
84400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84401       };
84402     }
84403   }
84404
84405   jresult = result;
84406   return jresult;
84407 }
84408
84409
84410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84411   void * jresult ;
84412   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84413   unsigned int arg2 ;
84414   Dali::Actor result;
84415
84416   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84417   arg2 = (unsigned int)jarg2;
84418   {
84419     try {
84420       result = (arg1)->GetActorByFocusOrder(arg2);
84421     } catch (std::out_of_range& e) {
84422       {
84423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84424       };
84425     } catch (std::exception& e) {
84426       {
84427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84428       };
84429     } catch (Dali::DaliException e) {
84430       {
84431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84432       };
84433     } catch (...) {
84434       {
84435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84436       };
84437     }
84438   }
84439
84440   jresult = new Dali::Actor((const Dali::Actor &)result);
84441   return jresult;
84442 }
84443
84444
84445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84446   unsigned int jresult ;
84447   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84448   Dali::Actor arg2 ;
84449   Dali::Actor *argp2 ;
84450   bool result;
84451
84452   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84453   argp2 = (Dali::Actor *)jarg2;
84454   if (!argp2) {
84455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84456     return 0;
84457   }
84458   arg2 = *argp2;
84459   {
84460     try {
84461       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84462     } catch (std::out_of_range& e) {
84463       {
84464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84465       };
84466     } catch (std::exception& e) {
84467       {
84468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84469       };
84470     } catch (Dali::DaliException e) {
84471       {
84472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84473       };
84474     } catch (...) {
84475       {
84476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84477       };
84478     }
84479   }
84480
84481   jresult = result;
84482   return jresult;
84483 }
84484
84485
84486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84487   void * jresult ;
84488   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84489   Dali::Actor result;
84490
84491   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84492   {
84493     try {
84494       result = (arg1)->GetCurrentFocusActor();
84495     } catch (std::out_of_range& e) {
84496       {
84497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84498       };
84499     } catch (std::exception& e) {
84500       {
84501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84502       };
84503     } catch (Dali::DaliException e) {
84504       {
84505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84506       };
84507     } catch (...) {
84508       {
84509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84510       };
84511     }
84512   }
84513
84514   jresult = new Dali::Actor((const Dali::Actor &)result);
84515   return jresult;
84516 }
84517
84518
84519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84520   void * jresult ;
84521   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84522   Dali::Actor result;
84523
84524   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84525   {
84526     try {
84527       result = (arg1)->GetCurrentFocusGroup();
84528     } catch (std::out_of_range& e) {
84529       {
84530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84531       };
84532     } catch (std::exception& e) {
84533       {
84534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84535       };
84536     } catch (Dali::DaliException e) {
84537       {
84538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84539       };
84540     } catch (...) {
84541       {
84542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84543       };
84544     }
84545   }
84546
84547   jresult = new Dali::Actor((const Dali::Actor &)result);
84548   return jresult;
84549 }
84550
84551
84552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84553   unsigned int jresult ;
84554   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84555   unsigned int result;
84556
84557   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84558   {
84559     try {
84560       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84561     } catch (std::out_of_range& e) {
84562       {
84563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84564       };
84565     } catch (std::exception& e) {
84566       {
84567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84568       };
84569     } catch (Dali::DaliException e) {
84570       {
84571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84572       };
84573     } catch (...) {
84574       {
84575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84576       };
84577     }
84578   }
84579
84580   jresult = result;
84581   return jresult;
84582 }
84583
84584
84585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84586   unsigned int jresult ;
84587   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84588   bool result;
84589
84590   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84591   {
84592     try {
84593       result = (bool)(arg1)->MoveFocusForward();
84594     } catch (std::out_of_range& e) {
84595       {
84596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84597       };
84598     } catch (std::exception& e) {
84599       {
84600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84601       };
84602     } catch (Dali::DaliException e) {
84603       {
84604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84605       };
84606     } catch (...) {
84607       {
84608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84609       };
84610     }
84611   }
84612
84613   jresult = result;
84614   return jresult;
84615 }
84616
84617
84618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84619   unsigned int jresult ;
84620   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84621   bool result;
84622
84623   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84624   {
84625     try {
84626       result = (bool)(arg1)->MoveFocusBackward();
84627     } catch (std::out_of_range& e) {
84628       {
84629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84630       };
84631     } catch (std::exception& e) {
84632       {
84633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84634       };
84635     } catch (Dali::DaliException e) {
84636       {
84637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84638       };
84639     } catch (...) {
84640       {
84641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84642       };
84643     }
84644   }
84645
84646   jresult = result;
84647   return jresult;
84648 }
84649
84650
84651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84652   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84653
84654   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84655   {
84656     try {
84657       (arg1)->ClearFocus();
84658     } catch (std::out_of_range& e) {
84659       {
84660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84661       };
84662     } catch (std::exception& e) {
84663       {
84664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84665       };
84666     } catch (Dali::DaliException e) {
84667       {
84668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84669       };
84670     } catch (...) {
84671       {
84672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84673       };
84674     }
84675   }
84676
84677 }
84678
84679
84680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84681   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84682
84683   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84684   {
84685     try {
84686       (arg1)->Reset();
84687     } catch (std::out_of_range& e) {
84688       {
84689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84690       };
84691     } catch (std::exception& e) {
84692       {
84693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84694       };
84695     } catch (Dali::DaliException e) {
84696       {
84697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84698       };
84699     } catch (...) {
84700       {
84701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84702       };
84703     }
84704   }
84705
84706 }
84707
84708
84709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84710   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84711   Dali::Actor arg2 ;
84712   bool arg3 ;
84713   Dali::Actor *argp2 ;
84714
84715   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84716   argp2 = (Dali::Actor *)jarg2;
84717   if (!argp2) {
84718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84719     return ;
84720   }
84721   arg2 = *argp2;
84722   arg3 = jarg3 ? true : false;
84723   {
84724     try {
84725       (arg1)->SetFocusGroup(arg2,arg3);
84726     } catch (std::out_of_range& e) {
84727       {
84728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84729       };
84730     } catch (std::exception& e) {
84731       {
84732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84733       };
84734     } catch (Dali::DaliException e) {
84735       {
84736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84737       };
84738     } catch (...) {
84739       {
84740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84741       };
84742     }
84743   }
84744
84745 }
84746
84747
84748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
84749   unsigned int jresult ;
84750   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84751   Dali::Actor arg2 ;
84752   Dali::Actor *argp2 ;
84753   bool result;
84754
84755   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84756   argp2 = (Dali::Actor *)jarg2;
84757   if (!argp2) {
84758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84759     return 0;
84760   }
84761   arg2 = *argp2;
84762   {
84763     try {
84764       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
84765     } catch (std::out_of_range& e) {
84766       {
84767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84768       };
84769     } catch (std::exception& e) {
84770       {
84771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84772       };
84773     } catch (Dali::DaliException e) {
84774       {
84775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84776       };
84777     } catch (...) {
84778       {
84779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84780       };
84781     }
84782   }
84783
84784   jresult = result;
84785   return jresult;
84786 }
84787
84788
84789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
84790   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84791   bool arg2 ;
84792
84793   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84794   arg2 = jarg2 ? true : false;
84795   {
84796     try {
84797       (arg1)->SetGroupMode(arg2);
84798     } catch (std::out_of_range& e) {
84799       {
84800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84801       };
84802     } catch (std::exception& e) {
84803       {
84804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84805       };
84806     } catch (Dali::DaliException e) {
84807       {
84808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84809       };
84810     } catch (...) {
84811       {
84812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84813       };
84814     }
84815   }
84816
84817 }
84818
84819
84820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
84821   unsigned int jresult ;
84822   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84823   bool result;
84824
84825   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84826   {
84827     try {
84828       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
84829     } catch (std::out_of_range& e) {
84830       {
84831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84832       };
84833     } catch (std::exception& e) {
84834       {
84835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84836       };
84837     } catch (Dali::DaliException e) {
84838       {
84839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84840       };
84841     } catch (...) {
84842       {
84843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84844       };
84845     }
84846   }
84847
84848   jresult = result;
84849   return jresult;
84850 }
84851
84852
84853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
84854   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84855   bool arg2 ;
84856
84857   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84858   arg2 = jarg2 ? true : false;
84859   {
84860     try {
84861       (arg1)->SetWrapMode(arg2);
84862     } catch (std::out_of_range& e) {
84863       {
84864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84865       };
84866     } catch (std::exception& e) {
84867       {
84868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84869       };
84870     } catch (Dali::DaliException e) {
84871       {
84872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84873       };
84874     } catch (...) {
84875       {
84876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84877       };
84878     }
84879   }
84880
84881 }
84882
84883
84884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
84885   unsigned int jresult ;
84886   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84887   bool result;
84888
84889   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84890   {
84891     try {
84892       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
84893     } catch (std::out_of_range& e) {
84894       {
84895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84896       };
84897     } catch (std::exception& e) {
84898       {
84899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84900       };
84901     } catch (Dali::DaliException e) {
84902       {
84903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84904       };
84905     } catch (...) {
84906       {
84907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84908       };
84909     }
84910   }
84911
84912   jresult = result;
84913   return jresult;
84914 }
84915
84916
84917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
84918   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84919   Dali::Actor arg2 ;
84920   Dali::Actor *argp2 ;
84921
84922   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84923   argp2 = (Dali::Actor *)jarg2;
84924   if (!argp2) {
84925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84926     return ;
84927   }
84928   arg2 = *argp2;
84929   {
84930     try {
84931       (arg1)->SetFocusIndicatorActor(arg2);
84932     } catch (std::out_of_range& e) {
84933       {
84934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84935       };
84936     } catch (std::exception& e) {
84937       {
84938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84939       };
84940     } catch (Dali::DaliException e) {
84941       {
84942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84943       };
84944     } catch (...) {
84945       {
84946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84947       };
84948     }
84949   }
84950
84951 }
84952
84953
84954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84955   void * jresult ;
84956   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84957   Dali::Actor result;
84958
84959   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84960   {
84961     try {
84962       result = (arg1)->GetFocusIndicatorActor();
84963     } catch (std::out_of_range& e) {
84964       {
84965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84966       };
84967     } catch (std::exception& e) {
84968       {
84969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84970       };
84971     } catch (Dali::DaliException e) {
84972       {
84973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84974       };
84975     } catch (...) {
84976       {
84977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84978       };
84979     }
84980   }
84981
84982   jresult = new Dali::Actor((const Dali::Actor &)result);
84983   return jresult;
84984 }
84985
84986
84987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84988   void * jresult ;
84989   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84990   Dali::Actor arg2 ;
84991   Dali::Actor *argp2 ;
84992   Dali::Actor result;
84993
84994   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84995   argp2 = (Dali::Actor *)jarg2;
84996   if (!argp2) {
84997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84998     return 0;
84999   }
85000   arg2 = *argp2;
85001   {
85002     try {
85003       result = (arg1)->GetFocusGroup(arg2);
85004     } catch (std::out_of_range& e) {
85005       {
85006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85007       };
85008     } catch (std::exception& e) {
85009       {
85010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85011       };
85012     } catch (Dali::DaliException e) {
85013       {
85014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85015       };
85016     } catch (...) {
85017       {
85018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85019       };
85020     }
85021   }
85022
85023   jresult = new Dali::Actor((const Dali::Actor &)result);
85024   return jresult;
85025 }
85026
85027
85028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85029   void * jresult ;
85030   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85031   Dali::Vector2 result;
85032
85033   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85034   {
85035     try {
85036       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85037     } catch (std::out_of_range& e) {
85038       {
85039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85040       };
85041     } catch (std::exception& e) {
85042       {
85043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85044       };
85045     } catch (Dali::DaliException e) {
85046       {
85047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85048       };
85049     } catch (...) {
85050       {
85051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85052       };
85053     }
85054   }
85055
85056   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85057   return jresult;
85058 }
85059
85060
85061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85062   void * jresult ;
85063   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85064   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85065
85066   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85067   {
85068     try {
85069       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85070     } catch (std::out_of_range& e) {
85071       {
85072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85073       };
85074     } catch (std::exception& e) {
85075       {
85076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85077       };
85078     } catch (Dali::DaliException e) {
85079       {
85080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85081       };
85082     } catch (...) {
85083       {
85084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85085       };
85086     }
85087   }
85088
85089   jresult = (void *)result;
85090   return jresult;
85091 }
85092
85093
85094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85095   void * jresult ;
85096   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85097   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85098
85099   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85100   {
85101     try {
85102       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85103     } catch (std::out_of_range& e) {
85104       {
85105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85106       };
85107     } catch (std::exception& e) {
85108       {
85109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85110       };
85111     } catch (Dali::DaliException e) {
85112       {
85113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85114       };
85115     } catch (...) {
85116       {
85117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85118       };
85119     }
85120   }
85121
85122   jresult = (void *)result;
85123   return jresult;
85124 }
85125
85126
85127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85128   void * jresult ;
85129   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85130   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85131
85132   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85133   {
85134     try {
85135       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85136     } catch (std::out_of_range& e) {
85137       {
85138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85139       };
85140     } catch (std::exception& e) {
85141       {
85142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85143       };
85144     } catch (Dali::DaliException e) {
85145       {
85146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85147       };
85148     } catch (...) {
85149       {
85150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85151       };
85152     }
85153   }
85154
85155   jresult = (void *)result;
85156   return jresult;
85157 }
85158
85159
85160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85161   void * jresult ;
85162   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85163   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85164
85165   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85166   {
85167     try {
85168       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85169     } catch (std::out_of_range& e) {
85170       {
85171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85172       };
85173     } catch (std::exception& e) {
85174       {
85175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85176       };
85177     } catch (Dali::DaliException e) {
85178       {
85179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85180       };
85181     } catch (...) {
85182       {
85183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85184       };
85185     }
85186   }
85187
85188   jresult = (void *)result;
85189   return jresult;
85190 }
85191
85192
85193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85194   void * jresult ;
85195   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85196   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85197
85198   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85199   {
85200     try {
85201       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85202     } catch (std::out_of_range& e) {
85203       {
85204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85205       };
85206     } catch (std::exception& e) {
85207       {
85208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85209       };
85210     } catch (Dali::DaliException e) {
85211       {
85212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85213       };
85214     } catch (...) {
85215       {
85216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85217       };
85218     }
85219   }
85220
85221   jresult = (void *)result;
85222   return jresult;
85223 }
85224
85225
85226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85227   void * jresult ;
85228   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85229   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85230
85231   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85232   {
85233     try {
85234       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85235     } catch (std::out_of_range& e) {
85236       {
85237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85238       };
85239     } catch (std::exception& e) {
85240       {
85241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85242       };
85243     } catch (Dali::DaliException e) {
85244       {
85245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85246       };
85247     } catch (...) {
85248       {
85249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85250       };
85251     }
85252   }
85253
85254   jresult = (void *)result;
85255   return jresult;
85256 }
85257
85258
85259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85260   void * jresult ;
85261   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85262   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85263
85264   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85265   {
85266     try {
85267       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85268     } catch (std::out_of_range& e) {
85269       {
85270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85271       };
85272     } catch (std::exception& e) {
85273       {
85274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85275       };
85276     } catch (Dali::DaliException e) {
85277       {
85278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85279       };
85280     } catch (...) {
85281       {
85282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85283       };
85284     }
85285   }
85286
85287   jresult = (void *)result;
85288   return jresult;
85289 }
85290
85291
85292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85293   void * jresult ;
85294   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85295   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85296
85297   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85298   {
85299     try {
85300       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85301     } catch (std::out_of_range& e) {
85302       {
85303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85304       };
85305     } catch (std::exception& e) {
85306       {
85307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85308       };
85309     } catch (Dali::DaliException e) {
85310       {
85311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85312       };
85313     } catch (...) {
85314       {
85315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85316       };
85317     }
85318   }
85319
85320   jresult = (void *)result;
85321   return jresult;
85322 }
85323
85324
85325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85326   void * jresult ;
85327   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85328   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85329
85330   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85331   {
85332     try {
85333       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85334     } catch (std::out_of_range& e) {
85335       {
85336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85337       };
85338     } catch (std::exception& e) {
85339       {
85340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85341       };
85342     } catch (Dali::DaliException e) {
85343       {
85344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85345       };
85346     } catch (...) {
85347       {
85348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85349       };
85350     }
85351   }
85352
85353   jresult = (void *)result;
85354   return jresult;
85355 }
85356
85357
85358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85359   void * jresult ;
85360   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85361   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85362
85363   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85364   {
85365     try {
85366       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85367     } catch (std::out_of_range& e) {
85368       {
85369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85370       };
85371     } catch (std::exception& e) {
85372       {
85373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85374       };
85375     } catch (Dali::DaliException e) {
85376       {
85377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85378       };
85379     } catch (...) {
85380       {
85381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85382       };
85383     }
85384   }
85385
85386   jresult = (void *)result;
85387   return jresult;
85388 }
85389
85390
85391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85392   void * jresult ;
85393   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85394   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85395
85396   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85397   {
85398     try {
85399       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85400     } catch (std::out_of_range& e) {
85401       {
85402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85403       };
85404     } catch (std::exception& e) {
85405       {
85406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85407       };
85408     } catch (Dali::DaliException e) {
85409       {
85410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85411       };
85412     } catch (...) {
85413       {
85414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85415       };
85416     }
85417   }
85418
85419   jresult = (void *)result;
85420   return jresult;
85421 }
85422
85423
85424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85425   void * jresult ;
85426   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85427   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85428
85429   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85430   {
85431     try {
85432       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85433     } catch (std::out_of_range& e) {
85434       {
85435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85436       };
85437     } catch (std::exception& e) {
85438       {
85439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85440       };
85441     } catch (Dali::DaliException e) {
85442       {
85443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85444       };
85445     } catch (...) {
85446       {
85447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85448       };
85449     }
85450   }
85451
85452   jresult = (void *)result;
85453   return jresult;
85454 }
85455
85456
85457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85458   void * jresult ;
85459   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85460   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85461
85462   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85463   {
85464     try {
85465       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85466     } catch (std::out_of_range& e) {
85467       {
85468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85469       };
85470     } catch (std::exception& e) {
85471       {
85472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85473       };
85474     } catch (Dali::DaliException e) {
85475       {
85476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85477       };
85478     } catch (...) {
85479       {
85480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85481       };
85482     }
85483   }
85484
85485   jresult = (void *)result;
85486   return jresult;
85487 }
85488
85489
85490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85491   void * jresult ;
85492   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85493   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85494
85495   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85496   {
85497     try {
85498       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85499     } catch (std::out_of_range& e) {
85500       {
85501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85502       };
85503     } catch (std::exception& e) {
85504       {
85505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85506       };
85507     } catch (Dali::DaliException e) {
85508       {
85509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85510       };
85511     } catch (...) {
85512       {
85513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85514       };
85515     }
85516   }
85517
85518   jresult = (void *)result;
85519   return jresult;
85520 }
85521
85522
85523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85524   void * jresult ;
85525   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85526   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85527
85528   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85529   {
85530     try {
85531       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85532     } catch (std::out_of_range& e) {
85533       {
85534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85535       };
85536     } catch (std::exception& e) {
85537       {
85538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85539       };
85540     } catch (Dali::DaliException e) {
85541       {
85542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85543       };
85544     } catch (...) {
85545       {
85546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85547       };
85548     }
85549   }
85550
85551   jresult = (void *)result;
85552   return jresult;
85553 }
85554
85555
85556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85557   void * jresult ;
85558   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85559   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85560
85561   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85562   {
85563     try {
85564       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85565     } catch (std::out_of_range& e) {
85566       {
85567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85568       };
85569     } catch (std::exception& e) {
85570       {
85571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85572       };
85573     } catch (Dali::DaliException e) {
85574       {
85575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85576       };
85577     } catch (...) {
85578       {
85579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85580       };
85581     }
85582   }
85583
85584   jresult = (void *)result;
85585   return jresult;
85586 }
85587
85588
85589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85590   void * jresult ;
85591   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85592   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85593
85594   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85595   {
85596     try {
85597       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85598     } catch (std::out_of_range& e) {
85599       {
85600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85601       };
85602     } catch (std::exception& e) {
85603       {
85604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85605       };
85606     } catch (Dali::DaliException e) {
85607       {
85608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85609       };
85610     } catch (...) {
85611       {
85612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85613       };
85614     }
85615   }
85616
85617   jresult = (void *)result;
85618   return jresult;
85619 }
85620
85621
85622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85623   void * jresult ;
85624   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85625   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85626
85627   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85628   {
85629     try {
85630       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85631     } catch (std::out_of_range& e) {
85632       {
85633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85634       };
85635     } catch (std::exception& e) {
85636       {
85637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85638       };
85639     } catch (Dali::DaliException e) {
85640       {
85641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85642       };
85643     } catch (...) {
85644       {
85645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85646       };
85647     }
85648   }
85649
85650   jresult = (void *)result;
85651   return jresult;
85652 }
85653
85654
85655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85656   void * jresult ;
85657   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85658   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85659
85660   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85661   {
85662     try {
85663       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85664     } catch (std::out_of_range& e) {
85665       {
85666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85667       };
85668     } catch (std::exception& e) {
85669       {
85670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85671       };
85672     } catch (Dali::DaliException e) {
85673       {
85674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85675       };
85676     } catch (...) {
85677       {
85678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85679       };
85680     }
85681   }
85682
85683   jresult = (void *)result;
85684   return jresult;
85685 }
85686
85687
85688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85689   void * jresult ;
85690   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85691   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85692
85693   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85694   {
85695     try {
85696       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85697     } catch (std::out_of_range& e) {
85698       {
85699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85700       };
85701     } catch (std::exception& e) {
85702       {
85703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85704       };
85705     } catch (Dali::DaliException e) {
85706       {
85707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85708       };
85709     } catch (...) {
85710       {
85711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85712       };
85713     }
85714   }
85715
85716   jresult = (void *)result;
85717   return jresult;
85718 }
85719
85720
85721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
85722   void * jresult ;
85723   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85724   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85725
85726   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85727   {
85728     try {
85729       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
85730     } catch (std::out_of_range& e) {
85731       {
85732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85733       };
85734     } catch (std::exception& e) {
85735       {
85736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85737       };
85738     } catch (Dali::DaliException e) {
85739       {
85740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85741       };
85742     } catch (...) {
85743       {
85744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85745       };
85746     }
85747   }
85748
85749   jresult = (void *)result;
85750   return jresult;
85751 }
85752
85753
85754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
85755   void * jresult ;
85756   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85757   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85758
85759   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85760   {
85761     try {
85762       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
85763     } catch (std::out_of_range& e) {
85764       {
85765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85766       };
85767     } catch (std::exception& e) {
85768       {
85769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85770       };
85771     } catch (Dali::DaliException e) {
85772       {
85773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85774       };
85775     } catch (...) {
85776       {
85777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85778       };
85779     }
85780   }
85781
85782   jresult = (void *)result;
85783   return jresult;
85784 }
85785
85786
85787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
85788   void * jresult ;
85789   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85790   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85791
85792   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85793   {
85794     try {
85795       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
85796     } catch (std::out_of_range& e) {
85797       {
85798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85799       };
85800     } catch (std::exception& e) {
85801       {
85802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85803       };
85804     } catch (Dali::DaliException e) {
85805       {
85806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85807       };
85808     } catch (...) {
85809       {
85810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85811       };
85812     }
85813   }
85814
85815   jresult = (void *)result;
85816   return jresult;
85817 }
85818
85819
85820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
85821   void * jresult ;
85822   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85823   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85824
85825   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85826   {
85827     try {
85828       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
85829     } catch (std::out_of_range& e) {
85830       {
85831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85832       };
85833     } catch (std::exception& e) {
85834       {
85835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85836       };
85837     } catch (Dali::DaliException e) {
85838       {
85839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85840       };
85841     } catch (...) {
85842       {
85843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85844       };
85845     }
85846   }
85847
85848   jresult = (void *)result;
85849   return jresult;
85850 }
85851
85852
85853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
85854   void * jresult ;
85855   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85856   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85857
85858   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85859   {
85860     try {
85861       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
85862     } catch (std::out_of_range& e) {
85863       {
85864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85865       };
85866     } catch (std::exception& e) {
85867       {
85868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85869       };
85870     } catch (Dali::DaliException e) {
85871       {
85872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85873       };
85874     } catch (...) {
85875       {
85876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85877       };
85878     }
85879   }
85880
85881   jresult = (void *)result;
85882   return jresult;
85883 }
85884
85885
85886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
85887   void * jresult ;
85888   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85889   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85890
85891   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85892   {
85893     try {
85894       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
85895     } catch (std::out_of_range& e) {
85896       {
85897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85898       };
85899     } catch (std::exception& e) {
85900       {
85901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85902       };
85903     } catch (Dali::DaliException e) {
85904       {
85905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85906       };
85907     } catch (...) {
85908       {
85909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85910       };
85911     }
85912   }
85913
85914   jresult = (void *)result;
85915   return jresult;
85916 }
85917
85918
85919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
85920   void * jresult ;
85921   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85922   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85923
85924   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85925   {
85926     try {
85927       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
85928     } catch (std::out_of_range& e) {
85929       {
85930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85931       };
85932     } catch (std::exception& e) {
85933       {
85934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85935       };
85936     } catch (Dali::DaliException e) {
85937       {
85938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85939       };
85940     } catch (...) {
85941       {
85942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85943       };
85944     }
85945   }
85946
85947   jresult = (void *)result;
85948   return jresult;
85949 }
85950
85951
85952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85953   void * jresult ;
85954   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85955   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85956
85957   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85958   {
85959     try {
85960       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85961     } catch (std::out_of_range& e) {
85962       {
85963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85964       };
85965     } catch (std::exception& e) {
85966       {
85967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85968       };
85969     } catch (Dali::DaliException e) {
85970       {
85971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85972       };
85973     } catch (...) {
85974       {
85975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85976       };
85977     }
85978   }
85979
85980   jresult = (void *)result;
85981   return jresult;
85982 }
85983
85984
85985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85986   void * jresult ;
85987   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85988   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85989
85990   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85991   {
85992     try {
85993       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85994     } catch (std::out_of_range& e) {
85995       {
85996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85997       };
85998     } catch (std::exception& e) {
85999       {
86000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86001       };
86002     } catch (Dali::DaliException e) {
86003       {
86004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86005       };
86006     } catch (...) {
86007       {
86008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86009       };
86010     }
86011   }
86012
86013   jresult = (void *)result;
86014   return jresult;
86015 }
86016
86017
86018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86019   void * jresult ;
86020   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86021   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86022
86023   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86024   {
86025     try {
86026       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86027     } catch (std::out_of_range& e) {
86028       {
86029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86030       };
86031     } catch (std::exception& e) {
86032       {
86033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86034       };
86035     } catch (Dali::DaliException e) {
86036       {
86037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86038       };
86039     } catch (...) {
86040       {
86041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86042       };
86043     }
86044   }
86045
86046   jresult = (void *)result;
86047   return jresult;
86048 }
86049
86050
86051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86052   void * jresult ;
86053   Dali::Toolkit::StyleManager *result = 0 ;
86054
86055   {
86056     try {
86057       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86058     } catch (std::out_of_range& e) {
86059       {
86060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86061       };
86062     } catch (std::exception& e) {
86063       {
86064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86065       };
86066     } catch (Dali::DaliException e) {
86067       {
86068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86069       };
86070     } catch (...) {
86071       {
86072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86073       };
86074     }
86075   }
86076
86077   jresult = (void *)result;
86078   return jresult;
86079 }
86080
86081
86082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86083   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86084
86085   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86086   {
86087     try {
86088       delete arg1;
86089     } catch (std::out_of_range& e) {
86090       {
86091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86092       };
86093     } catch (std::exception& e) {
86094       {
86095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86096       };
86097     } catch (Dali::DaliException e) {
86098       {
86099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86100       };
86101     } catch (...) {
86102       {
86103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86104       };
86105     }
86106   }
86107
86108 }
86109
86110
86111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86112   void * jresult ;
86113   Dali::Toolkit::StyleManager result;
86114
86115   {
86116     try {
86117       result = Dali::Toolkit::StyleManager::Get();
86118     } catch (std::out_of_range& e) {
86119       {
86120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86121       };
86122     } catch (std::exception& e) {
86123       {
86124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86125       };
86126     } catch (Dali::DaliException e) {
86127       {
86128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86129       };
86130     } catch (...) {
86131       {
86132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86133       };
86134     }
86135   }
86136
86137   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86138   return jresult;
86139 }
86140
86141
86142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86143   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86144   std::string *arg2 = 0 ;
86145
86146   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86147   if (!jarg2) {
86148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86149     return ;
86150   }
86151   std::string arg2_str(jarg2);
86152   arg2 = &arg2_str;
86153   {
86154     try {
86155       (arg1)->ApplyTheme((std::string const &)*arg2);
86156     } catch (std::out_of_range& e) {
86157       {
86158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86159       };
86160     } catch (std::exception& e) {
86161       {
86162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86163       };
86164     } catch (Dali::DaliException e) {
86165       {
86166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86167       };
86168     } catch (...) {
86169       {
86170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86171       };
86172     }
86173   }
86174
86175
86176   //argout typemap for const std::string&
86177
86178 }
86179
86180
86181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86182   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86183
86184   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86185   {
86186     try {
86187       (arg1)->ApplyDefaultTheme();
86188     } catch (std::out_of_range& e) {
86189       {
86190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86191       };
86192     } catch (std::exception& e) {
86193       {
86194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86195       };
86196     } catch (Dali::DaliException e) {
86197       {
86198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86199       };
86200     } catch (...) {
86201       {
86202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86203       };
86204     }
86205   }
86206
86207 }
86208
86209
86210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86211   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86212   std::string *arg2 = 0 ;
86213   Dali::Property::Value *arg3 = 0 ;
86214
86215   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86216   if (!jarg2) {
86217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86218     return ;
86219   }
86220   std::string arg2_str(jarg2);
86221   arg2 = &arg2_str;
86222   arg3 = (Dali::Property::Value *)jarg3;
86223   if (!arg3) {
86224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86225     return ;
86226   }
86227   {
86228     try {
86229       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86230     } catch (std::out_of_range& e) {
86231       {
86232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86233       };
86234     } catch (std::exception& e) {
86235       {
86236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86237       };
86238     } catch (Dali::DaliException e) {
86239       {
86240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86241       };
86242     } catch (...) {
86243       {
86244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86245       };
86246     }
86247   }
86248
86249
86250   //argout typemap for const std::string&
86251
86252 }
86253
86254
86255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86256   unsigned int jresult ;
86257   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86258   std::string *arg2 = 0 ;
86259   Dali::Property::Value *arg3 = 0 ;
86260   bool result;
86261
86262   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86263   if (!jarg2) {
86264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86265     return 0;
86266   }
86267   std::string arg2_str(jarg2);
86268   arg2 = &arg2_str;
86269   arg3 = (Dali::Property::Value *)jarg3;
86270   if (!arg3) {
86271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86272     return 0;
86273   }
86274   {
86275     try {
86276       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86277     } catch (std::out_of_range& e) {
86278       {
86279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86280       };
86281     } catch (std::exception& e) {
86282       {
86283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86284       };
86285     } catch (Dali::DaliException e) {
86286       {
86287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86288       };
86289     } catch (...) {
86290       {
86291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86292       };
86293     }
86294   }
86295
86296   jresult = result;
86297
86298   //argout typemap for const std::string&
86299
86300   return jresult;
86301 }
86302
86303
86304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86305   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86306   Dali::Toolkit::Control arg2 ;
86307   std::string *arg3 = 0 ;
86308   std::string *arg4 = 0 ;
86309   Dali::Toolkit::Control *argp2 ;
86310
86311   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86312   argp2 = (Dali::Toolkit::Control *)jarg2;
86313   if (!argp2) {
86314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86315     return ;
86316   }
86317   arg2 = *argp2;
86318   if (!jarg3) {
86319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86320     return ;
86321   }
86322   std::string arg3_str(jarg3);
86323   arg3 = &arg3_str;
86324   if (!jarg4) {
86325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86326     return ;
86327   }
86328   std::string arg4_str(jarg4);
86329   arg4 = &arg4_str;
86330   {
86331     try {
86332       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86333     } catch (std::out_of_range& e) {
86334       {
86335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86336       };
86337     } catch (std::exception& e) {
86338       {
86339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86340       };
86341     } catch (Dali::DaliException e) {
86342       {
86343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86344       };
86345     } catch (...) {
86346       {
86347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86348       };
86349     }
86350   }
86351
86352
86353   //argout typemap for const std::string&
86354
86355
86356   //argout typemap for const std::string&
86357
86358 }
86359
86360
86361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86362   void * jresult ;
86363   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86364   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86365
86366   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86367   {
86368     try {
86369       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86370     } catch (std::out_of_range& e) {
86371       {
86372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86373       };
86374     } catch (std::exception& e) {
86375       {
86376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86377       };
86378     } catch (Dali::DaliException e) {
86379       {
86380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86381       };
86382     } catch (...) {
86383       {
86384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86385       };
86386     }
86387   }
86388
86389   jresult = (void *)result;
86390   return jresult;
86391 }
86392
86393
86394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86395   int jresult ;
86396   int result;
86397
86398   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86399   jresult = (int)result;
86400   return jresult;
86401 }
86402
86403
86404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86405   int jresult ;
86406   int result;
86407
86408   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86409   jresult = (int)result;
86410   return jresult;
86411 }
86412
86413
86414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86415   int jresult ;
86416   int result;
86417
86418   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86419   jresult = (int)result;
86420   return jresult;
86421 }
86422
86423
86424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86425   int jresult ;
86426   int result;
86427
86428   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86429   jresult = (int)result;
86430   return jresult;
86431 }
86432
86433
86434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86435   int jresult ;
86436   int result;
86437
86438   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86439   jresult = (int)result;
86440   return jresult;
86441 }
86442
86443
86444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86445   int jresult ;
86446   int result;
86447
86448   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86449   jresult = (int)result;
86450   return jresult;
86451 }
86452
86453
86454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86455   int jresult ;
86456   int result;
86457
86458   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86459   jresult = (int)result;
86460   return jresult;
86461 }
86462
86463
86464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86465   int jresult ;
86466   int result;
86467
86468   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86469   jresult = (int)result;
86470   return jresult;
86471 }
86472
86473
86474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86475   int jresult ;
86476   int result;
86477
86478   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86479   jresult = (int)result;
86480   return jresult;
86481 }
86482
86483
86484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86485   int jresult ;
86486   int result;
86487
86488   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86489   jresult = (int)result;
86490   return jresult;
86491 }
86492
86493
86494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86495   int jresult ;
86496   int result;
86497
86498   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86499   jresult = (int)result;
86500   return jresult;
86501 }
86502
86503
86504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86505   int jresult ;
86506   int result;
86507
86508   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86509   jresult = (int)result;
86510   return jresult;
86511 }
86512
86513
86514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86515   int jresult ;
86516   int result;
86517
86518   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86519   jresult = (int)result;
86520   return jresult;
86521 }
86522
86523
86524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86525   int jresult ;
86526   int result;
86527
86528   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86529   jresult = (int)result;
86530   return jresult;
86531 }
86532
86533
86534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86535   int jresult ;
86536   int result;
86537
86538   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86539   jresult = (int)result;
86540   return jresult;
86541 }
86542
86543
86544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86545   void * jresult ;
86546   Dali::Toolkit::Slider::Property *result = 0 ;
86547
86548   {
86549     try {
86550       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86551     } catch (std::out_of_range& e) {
86552       {
86553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86554       };
86555     } catch (std::exception& e) {
86556       {
86557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86558       };
86559     } catch (Dali::DaliException e) {
86560       {
86561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86562       };
86563     } catch (...) {
86564       {
86565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86566       };
86567     }
86568   }
86569
86570   jresult = (void *)result;
86571   return jresult;
86572 }
86573
86574
86575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86576   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86577
86578   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86579   {
86580     try {
86581       delete arg1;
86582     } catch (std::out_of_range& e) {
86583       {
86584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86585       };
86586     } catch (std::exception& e) {
86587       {
86588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86589       };
86590     } catch (Dali::DaliException e) {
86591       {
86592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86593       };
86594     } catch (...) {
86595       {
86596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86597       };
86598     }
86599   }
86600
86601 }
86602
86603
86604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86605   void * jresult ;
86606   Dali::Toolkit::Slider result;
86607
86608   {
86609     try {
86610       result = Dali::Toolkit::Slider::New();
86611     } catch (std::out_of_range& e) {
86612       {
86613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86614       };
86615     } catch (std::exception& e) {
86616       {
86617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86618       };
86619     } catch (Dali::DaliException e) {
86620       {
86621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86622       };
86623     } catch (...) {
86624       {
86625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86626       };
86627     }
86628   }
86629
86630   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86631   return jresult;
86632 }
86633
86634
86635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86636   void * jresult ;
86637   Dali::Toolkit::Slider *result = 0 ;
86638
86639   {
86640     try {
86641       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86642     } catch (std::out_of_range& e) {
86643       {
86644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86645       };
86646     } catch (std::exception& e) {
86647       {
86648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86649       };
86650     } catch (Dali::DaliException e) {
86651       {
86652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86653       };
86654     } catch (...) {
86655       {
86656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86657       };
86658     }
86659   }
86660
86661   jresult = (void *)result;
86662   return jresult;
86663 }
86664
86665
86666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86667   void * jresult ;
86668   Dali::Toolkit::Slider *arg1 = 0 ;
86669   Dali::Toolkit::Slider *result = 0 ;
86670
86671   arg1 = (Dali::Toolkit::Slider *)jarg1;
86672   if (!arg1) {
86673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86674     return 0;
86675   }
86676   {
86677     try {
86678       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86679     } catch (std::out_of_range& e) {
86680       {
86681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86682       };
86683     } catch (std::exception& e) {
86684       {
86685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86686       };
86687     } catch (Dali::DaliException e) {
86688       {
86689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86690       };
86691     } catch (...) {
86692       {
86693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86694       };
86695     }
86696   }
86697
86698   jresult = (void *)result;
86699   return jresult;
86700 }
86701
86702
86703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86704   void * jresult ;
86705   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86706   Dali::Toolkit::Slider *arg2 = 0 ;
86707   Dali::Toolkit::Slider *result = 0 ;
86708
86709   arg1 = (Dali::Toolkit::Slider *)jarg1;
86710   arg2 = (Dali::Toolkit::Slider *)jarg2;
86711   if (!arg2) {
86712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86713     return 0;
86714   }
86715   {
86716     try {
86717       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
86718     } catch (std::out_of_range& e) {
86719       {
86720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86721       };
86722     } catch (std::exception& e) {
86723       {
86724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86725       };
86726     } catch (Dali::DaliException e) {
86727       {
86728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86729       };
86730     } catch (...) {
86731       {
86732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86733       };
86734     }
86735   }
86736
86737   jresult = (void *)result;
86738   return jresult;
86739 }
86740
86741
86742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
86743   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86744
86745   arg1 = (Dali::Toolkit::Slider *)jarg1;
86746   {
86747     try {
86748       delete arg1;
86749     } catch (std::out_of_range& e) {
86750       {
86751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86752       };
86753     } catch (std::exception& e) {
86754       {
86755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86756       };
86757     } catch (Dali::DaliException e) {
86758       {
86759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86760       };
86761     } catch (...) {
86762       {
86763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86764       };
86765     }
86766   }
86767
86768 }
86769
86770
86771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
86772   void * jresult ;
86773   Dali::BaseHandle arg1 ;
86774   Dali::BaseHandle *argp1 ;
86775   Dali::Toolkit::Slider result;
86776
86777   argp1 = (Dali::BaseHandle *)jarg1;
86778   if (!argp1) {
86779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86780     return 0;
86781   }
86782   arg1 = *argp1;
86783   {
86784     try {
86785       result = Dali::Toolkit::Slider::DownCast(arg1);
86786     } catch (std::out_of_range& e) {
86787       {
86788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86789       };
86790     } catch (std::exception& e) {
86791       {
86792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86793       };
86794     } catch (Dali::DaliException e) {
86795       {
86796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86797       };
86798     } catch (...) {
86799       {
86800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86801       };
86802     }
86803   }
86804
86805   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86806   return jresult;
86807 }
86808
86809
86810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
86811   void * jresult ;
86812   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86813   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86814
86815   arg1 = (Dali::Toolkit::Slider *)jarg1;
86816   {
86817     try {
86818       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
86819     } catch (std::out_of_range& e) {
86820       {
86821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86822       };
86823     } catch (std::exception& e) {
86824       {
86825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86826       };
86827     } catch (Dali::DaliException e) {
86828       {
86829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86830       };
86831     } catch (...) {
86832       {
86833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86834       };
86835     }
86836   }
86837
86838   jresult = (void *)result;
86839   return jresult;
86840 }
86841
86842
86843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
86844   void * jresult ;
86845   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86846   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86847
86848   arg1 = (Dali::Toolkit::Slider *)jarg1;
86849   {
86850     try {
86851       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
86852     } catch (std::out_of_range& e) {
86853       {
86854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86855       };
86856     } catch (std::exception& e) {
86857       {
86858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86859       };
86860     } catch (Dali::DaliException e) {
86861       {
86862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86863       };
86864     } catch (...) {
86865       {
86866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86867       };
86868     }
86869   }
86870
86871   jresult = (void *)result;
86872   return jresult;
86873 }
86874
86875
86876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
86877   void * jresult ;
86878   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86879   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
86880
86881   arg1 = (Dali::Toolkit::Slider *)jarg1;
86882   {
86883     try {
86884       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
86885     } catch (std::out_of_range& e) {
86886       {
86887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86888       };
86889     } catch (std::exception& e) {
86890       {
86891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86892       };
86893     } catch (Dali::DaliException e) {
86894       {
86895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86896       };
86897     } catch (...) {
86898       {
86899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86900       };
86901     }
86902   }
86903
86904   jresult = (void *)result;
86905   return jresult;
86906 }
86907
86908
86909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
86910   int jresult ;
86911   int result;
86912
86913   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
86914   jresult = (int)result;
86915   return jresult;
86916 }
86917
86918
86919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
86920   int jresult ;
86921   int result;
86922
86923   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
86924   jresult = (int)result;
86925   return jresult;
86926 }
86927
86928
86929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
86930   int jresult ;
86931   int result;
86932
86933   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
86934   jresult = (int)result;
86935   return jresult;
86936 }
86937
86938
86939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86940   int jresult ;
86941   int result;
86942
86943   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86944   jresult = (int)result;
86945   return jresult;
86946 }
86947
86948
86949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86950   int result;
86951
86952   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86953
86954   return result;
86955 }
86956
86957
86958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86959   void * jresult ;
86960   Dali::Toolkit::VideoView::Property *result = 0 ;
86961
86962   {
86963     try {
86964       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86965     } catch (std::out_of_range& e) {
86966       {
86967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86968       };
86969     } catch (std::exception& e) {
86970       {
86971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86972       };
86973     } catch (Dali::DaliException e) {
86974       {
86975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86976       };
86977     } catch (...) {
86978       {
86979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86980       };
86981     }
86982   }
86983
86984   jresult = (void *)result;
86985   return jresult;
86986 }
86987
86988
86989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86990   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86991
86992   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86993   {
86994     try {
86995       delete arg1;
86996     } catch (std::out_of_range& e) {
86997       {
86998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86999       };
87000     } catch (std::exception& e) {
87001       {
87002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87003       };
87004     } catch (Dali::DaliException e) {
87005       {
87006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87007       };
87008     } catch (...) {
87009       {
87010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87011       };
87012     }
87013   }
87014
87015 }
87016
87017
87018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87019   void * jresult ;
87020   Dali::Toolkit::VideoView result;
87021
87022   {
87023     try {
87024       result = Dali::Toolkit::VideoView::New();
87025     } catch (std::out_of_range& e) {
87026       {
87027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87028       };
87029     } catch (std::exception& e) {
87030       {
87031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87032       };
87033     } catch (Dali::DaliException e) {
87034       {
87035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87036       };
87037     } catch (...) {
87038       {
87039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87040       };
87041     }
87042   }
87043
87044   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87045   return jresult;
87046 }
87047
87048
87049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87050   void * jresult ;
87051   std::string *arg1 = 0 ;
87052   Dali::Toolkit::VideoView result;
87053
87054   if (!jarg1) {
87055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87056     return 0;
87057   }
87058   std::string arg1_str(jarg1);
87059   arg1 = &arg1_str;
87060   {
87061     try {
87062       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87063     } catch (std::out_of_range& e) {
87064       {
87065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87066       };
87067     } catch (std::exception& e) {
87068       {
87069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87070       };
87071     } catch (Dali::DaliException e) {
87072       {
87073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87074       };
87075     } catch (...) {
87076       {
87077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87078       };
87079     }
87080   }
87081
87082   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87083
87084   //argout typemap for const std::string&
87085
87086   return jresult;
87087 }
87088
87089
87090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87091   void * jresult ;
87092   Dali::Toolkit::VideoView *result = 0 ;
87093
87094   {
87095     try {
87096       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87097     } catch (std::out_of_range& e) {
87098       {
87099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87100       };
87101     } catch (std::exception& e) {
87102       {
87103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87104       };
87105     } catch (Dali::DaliException e) {
87106       {
87107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87108       };
87109     } catch (...) {
87110       {
87111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87112       };
87113     }
87114   }
87115
87116   jresult = (void *)result;
87117   return jresult;
87118 }
87119
87120
87121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87122   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87123
87124   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87125   {
87126     try {
87127       delete arg1;
87128     } catch (std::out_of_range& e) {
87129       {
87130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87131       };
87132     } catch (std::exception& e) {
87133       {
87134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87135       };
87136     } catch (Dali::DaliException e) {
87137       {
87138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87139       };
87140     } catch (...) {
87141       {
87142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87143       };
87144     }
87145   }
87146
87147 }
87148
87149
87150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87151   void * jresult ;
87152   Dali::Toolkit::VideoView *arg1 = 0 ;
87153   Dali::Toolkit::VideoView *result = 0 ;
87154
87155   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87156   if (!arg1) {
87157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87158     return 0;
87159   }
87160   {
87161     try {
87162       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87163     } catch (std::out_of_range& e) {
87164       {
87165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87166       };
87167     } catch (std::exception& e) {
87168       {
87169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87170       };
87171     } catch (Dali::DaliException e) {
87172       {
87173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87174       };
87175     } catch (...) {
87176       {
87177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87178       };
87179     }
87180   }
87181
87182   jresult = (void *)result;
87183   return jresult;
87184 }
87185
87186
87187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87188   void * jresult ;
87189   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87190   Dali::Toolkit::VideoView *arg2 = 0 ;
87191   Dali::Toolkit::VideoView *result = 0 ;
87192
87193   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87194   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87195   if (!arg2) {
87196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87197     return 0;
87198   }
87199   {
87200     try {
87201       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87202     } catch (std::out_of_range& e) {
87203       {
87204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87205       };
87206     } catch (std::exception& e) {
87207       {
87208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87209       };
87210     } catch (Dali::DaliException e) {
87211       {
87212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87213       };
87214     } catch (...) {
87215       {
87216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87217       };
87218     }
87219   }
87220
87221   jresult = (void *)result;
87222   return jresult;
87223 }
87224
87225
87226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87227   void * jresult ;
87228   Dali::BaseHandle arg1 ;
87229   Dali::BaseHandle *argp1 ;
87230   Dali::Toolkit::VideoView result;
87231
87232   argp1 = (Dali::BaseHandle *)jarg1;
87233   if (!argp1) {
87234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87235     return 0;
87236   }
87237   arg1 = *argp1;
87238   {
87239     try {
87240       result = Dali::Toolkit::VideoView::DownCast(arg1);
87241     } catch (std::out_of_range& e) {
87242       {
87243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87244       };
87245     } catch (std::exception& e) {
87246       {
87247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87248       };
87249     } catch (Dali::DaliException e) {
87250       {
87251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87252       };
87253     } catch (...) {
87254       {
87255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87256       };
87257     }
87258   }
87259
87260   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87261   return jresult;
87262 }
87263
87264
87265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87266   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87267
87268   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87269   {
87270     try {
87271       (arg1)->Play();
87272     } catch (std::out_of_range& e) {
87273       {
87274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87275       };
87276     } catch (std::exception& e) {
87277       {
87278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87279       };
87280     } catch (Dali::DaliException e) {
87281       {
87282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87283       };
87284     } catch (...) {
87285       {
87286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87287       };
87288     }
87289   }
87290
87291 }
87292
87293
87294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87295   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87296
87297   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87298   {
87299     try {
87300       (arg1)->Pause();
87301     } catch (std::out_of_range& e) {
87302       {
87303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87304       };
87305     } catch (std::exception& e) {
87306       {
87307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87308       };
87309     } catch (Dali::DaliException e) {
87310       {
87311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87312       };
87313     } catch (...) {
87314       {
87315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87316       };
87317     }
87318   }
87319
87320 }
87321
87322
87323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87324   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87325
87326   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87327   {
87328     try {
87329       (arg1)->Stop();
87330     } catch (std::out_of_range& e) {
87331       {
87332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87333       };
87334     } catch (std::exception& e) {
87335       {
87336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87337       };
87338     } catch (Dali::DaliException e) {
87339       {
87340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87341       };
87342     } catch (...) {
87343       {
87344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87345       };
87346     }
87347   }
87348
87349 }
87350
87351
87352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87353   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87354   int arg2 ;
87355
87356   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87357   arg2 = (int)jarg2;
87358   {
87359     try {
87360       (arg1)->Forward(arg2);
87361     } catch (std::out_of_range& e) {
87362       {
87363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87364       };
87365     } catch (std::exception& e) {
87366       {
87367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87368       };
87369     } catch (Dali::DaliException e) {
87370       {
87371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87372       };
87373     } catch (...) {
87374       {
87375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87376       };
87377     }
87378   }
87379
87380 }
87381
87382
87383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87384   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87385   int arg2 ;
87386
87387   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87388   arg2 = (int)jarg2;
87389   {
87390     try {
87391       (arg1)->Backward(arg2);
87392     } catch (std::out_of_range& e) {
87393       {
87394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87395       };
87396     } catch (std::exception& e) {
87397       {
87398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87399       };
87400     } catch (Dali::DaliException e) {
87401       {
87402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87403       };
87404     } catch (...) {
87405       {
87406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87407       };
87408     }
87409   }
87410
87411 }
87412
87413
87414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87415   void * jresult ;
87416   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87417   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87418
87419   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87420   {
87421     try {
87422       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
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 int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87448   int jresult ;
87449   int result;
87450
87451   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87452   jresult = (int)result;
87453   return jresult;
87454 }
87455
87456
87457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87458   int jresult ;
87459   int result;
87460
87461   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87462   jresult = (int)result;
87463   return jresult;
87464 }
87465
87466
87467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87468   int jresult ;
87469   int result;
87470
87471   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87472   jresult = (int)result;
87473   return jresult;
87474 }
87475
87476
87477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87478   int jresult ;
87479   int result;
87480
87481   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87482   jresult = (int)result;
87483   return jresult;
87484 }
87485
87486
87487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87488   int jresult ;
87489   int result;
87490
87491   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87492   jresult = (int)result;
87493   return jresult;
87494 }
87495
87496
87497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87498   int jresult ;
87499   int result;
87500
87501   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87502   jresult = (int)result;
87503   return jresult;
87504 }
87505
87506
87507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87508   int jresult ;
87509   int result;
87510
87511   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87512   jresult = (int)result;
87513   return jresult;
87514 }
87515
87516
87517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87518   int jresult ;
87519   int result;
87520
87521   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87522   jresult = (int)result;
87523   return jresult;
87524 }
87525
87526
87527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87528   int jresult ;
87529   int result;
87530
87531   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87532   jresult = (int)result;
87533   return jresult;
87534 }
87535
87536
87537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87538   int jresult ;
87539   int result;
87540
87541   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87542   jresult = (int)result;
87543   return jresult;
87544 }
87545
87546
87547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87548   int jresult ;
87549   int result;
87550
87551   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87552   jresult = (int)result;
87553   return jresult;
87554 }
87555
87556
87557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87558   int jresult ;
87559   int result;
87560
87561   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87562   jresult = (int)result;
87563   return jresult;
87564 }
87565
87566
87567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87568   int jresult ;
87569   int result;
87570
87571   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87572   jresult = (int)result;
87573   return jresult;
87574 }
87575
87576
87577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87578   int jresult ;
87579   int result;
87580
87581   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87582   jresult = (int)result;
87583   return jresult;
87584 }
87585
87586
87587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87588   int jresult ;
87589   int result;
87590
87591   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87592   jresult = (int)result;
87593   return jresult;
87594 }
87595
87596
87597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87598   int jresult ;
87599   int result;
87600
87601   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87602   jresult = (int)result;
87603   return jresult;
87604 }
87605
87606
87607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87608   int jresult ;
87609   int result;
87610
87611   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87612   jresult = (int)result;
87613   return jresult;
87614 }
87615
87616
87617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87618   int jresult ;
87619   int result;
87620
87621   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87622   jresult = (int)result;
87623   return jresult;
87624 }
87625
87626
87627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87628   int jresult ;
87629   int result;
87630
87631   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87632   jresult = (int)result;
87633   return jresult;
87634 }
87635
87636
87637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87638   int jresult ;
87639   int result;
87640
87641   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87642   jresult = (int)result;
87643   return jresult;
87644 }
87645
87646
87647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87648   int jresult ;
87649   int result;
87650
87651   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87652   jresult = (int)result;
87653   return jresult;
87654 }
87655
87656
87657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87658   void * jresult ;
87659   Dali::Toolkit::Popup::Property *result = 0 ;
87660
87661   {
87662     try {
87663       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87664     } catch (std::out_of_range& e) {
87665       {
87666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87667       };
87668     } catch (std::exception& e) {
87669       {
87670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87671       };
87672     } catch (Dali::DaliException e) {
87673       {
87674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87675       };
87676     } catch (...) {
87677       {
87678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87679       };
87680     }
87681   }
87682
87683   jresult = (void *)result;
87684   return jresult;
87685 }
87686
87687
87688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87689   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87690
87691   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87692   {
87693     try {
87694       delete arg1;
87695     } catch (std::out_of_range& e) {
87696       {
87697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87698       };
87699     } catch (std::exception& e) {
87700       {
87701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87702       };
87703     } catch (Dali::DaliException e) {
87704       {
87705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87706       };
87707     } catch (...) {
87708       {
87709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87710       };
87711     }
87712   }
87713
87714 }
87715
87716
87717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
87718   void * jresult ;
87719   Dali::Toolkit::Popup *result = 0 ;
87720
87721   {
87722     try {
87723       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
87724     } catch (std::out_of_range& e) {
87725       {
87726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87727       };
87728     } catch (std::exception& e) {
87729       {
87730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87731       };
87732     } catch (Dali::DaliException e) {
87733       {
87734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87735       };
87736     } catch (...) {
87737       {
87738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87739       };
87740     }
87741   }
87742
87743   jresult = (void *)result;
87744   return jresult;
87745 }
87746
87747
87748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87749   void * jresult ;
87750   Dali::Toolkit::Popup result;
87751
87752   {
87753     try {
87754       result = Dali::Toolkit::Popup::New();
87755     } catch (std::out_of_range& e) {
87756       {
87757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87758       };
87759     } catch (std::exception& e) {
87760       {
87761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87762       };
87763     } catch (Dali::DaliException e) {
87764       {
87765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87766       };
87767     } catch (...) {
87768       {
87769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87770       };
87771     }
87772   }
87773
87774   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87775   return jresult;
87776 }
87777
87778
87779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87780   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87781
87782   arg1 = (Dali::Toolkit::Popup *)jarg1;
87783   {
87784     try {
87785       delete arg1;
87786     } catch (std::out_of_range& e) {
87787       {
87788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87789       };
87790     } catch (std::exception& e) {
87791       {
87792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87793       };
87794     } catch (Dali::DaliException e) {
87795       {
87796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87797       };
87798     } catch (...) {
87799       {
87800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87801       };
87802     }
87803   }
87804
87805 }
87806
87807
87808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
87809   void * jresult ;
87810   Dali::Toolkit::Popup *arg1 = 0 ;
87811   Dali::Toolkit::Popup *result = 0 ;
87812
87813   arg1 = (Dali::Toolkit::Popup *)jarg1;
87814   if (!arg1) {
87815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87816     return 0;
87817   }
87818   {
87819     try {
87820       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
87821     } catch (std::out_of_range& e) {
87822       {
87823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87824       };
87825     } catch (std::exception& e) {
87826       {
87827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87828       };
87829     } catch (Dali::DaliException e) {
87830       {
87831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87832       };
87833     } catch (...) {
87834       {
87835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87836       };
87837     }
87838   }
87839
87840   jresult = (void *)result;
87841   return jresult;
87842 }
87843
87844
87845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
87846   void * jresult ;
87847   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87848   Dali::Toolkit::Popup *arg2 = 0 ;
87849   Dali::Toolkit::Popup *result = 0 ;
87850
87851   arg1 = (Dali::Toolkit::Popup *)jarg1;
87852   arg2 = (Dali::Toolkit::Popup *)jarg2;
87853   if (!arg2) {
87854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87855     return 0;
87856   }
87857   {
87858     try {
87859       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
87860     } catch (std::out_of_range& e) {
87861       {
87862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87863       };
87864     } catch (std::exception& e) {
87865       {
87866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87867       };
87868     } catch (Dali::DaliException e) {
87869       {
87870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87871       };
87872     } catch (...) {
87873       {
87874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87875       };
87876     }
87877   }
87878
87879   jresult = (void *)result;
87880   return jresult;
87881 }
87882
87883
87884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
87885   void * jresult ;
87886   Dali::BaseHandle arg1 ;
87887   Dali::BaseHandle *argp1 ;
87888   Dali::Toolkit::Popup result;
87889
87890   argp1 = (Dali::BaseHandle *)jarg1;
87891   if (!argp1) {
87892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87893     return 0;
87894   }
87895   arg1 = *argp1;
87896   {
87897     try {
87898       result = Dali::Toolkit::Popup::DownCast(arg1);
87899     } catch (std::out_of_range& e) {
87900       {
87901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87902       };
87903     } catch (std::exception& e) {
87904       {
87905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87906       };
87907     } catch (Dali::DaliException e) {
87908       {
87909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87910       };
87911     } catch (...) {
87912       {
87913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87914       };
87915     }
87916   }
87917
87918   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87919   return jresult;
87920 }
87921
87922
87923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
87924   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87925   Dali::Actor arg2 ;
87926   Dali::Actor *argp2 ;
87927
87928   arg1 = (Dali::Toolkit::Popup *)jarg1;
87929   argp2 = (Dali::Actor *)jarg2;
87930   if (!argp2) {
87931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87932     return ;
87933   }
87934   arg2 = *argp2;
87935   {
87936     try {
87937       (arg1)->SetTitle(arg2);
87938     } catch (std::out_of_range& e) {
87939       {
87940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87941       };
87942     } catch (std::exception& e) {
87943       {
87944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87945       };
87946     } catch (Dali::DaliException e) {
87947       {
87948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87949       };
87950     } catch (...) {
87951       {
87952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87953       };
87954     }
87955   }
87956
87957 }
87958
87959
87960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87961   void * jresult ;
87962   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87963   Dali::Actor result;
87964
87965   arg1 = (Dali::Toolkit::Popup *)jarg1;
87966   {
87967     try {
87968       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87969     } catch (std::out_of_range& e) {
87970       {
87971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87972       };
87973     } catch (std::exception& e) {
87974       {
87975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87976       };
87977     } catch (Dali::DaliException e) {
87978       {
87979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87980       };
87981     } catch (...) {
87982       {
87983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87984       };
87985     }
87986   }
87987
87988   jresult = new Dali::Actor((const Dali::Actor &)result);
87989   return jresult;
87990 }
87991
87992
87993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87994   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87995   Dali::Actor arg2 ;
87996   Dali::Actor *argp2 ;
87997
87998   arg1 = (Dali::Toolkit::Popup *)jarg1;
87999   argp2 = (Dali::Actor *)jarg2;
88000   if (!argp2) {
88001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88002     return ;
88003   }
88004   arg2 = *argp2;
88005   {
88006     try {
88007       (arg1)->SetContent(arg2);
88008     } catch (std::out_of_range& e) {
88009       {
88010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88011       };
88012     } catch (std::exception& e) {
88013       {
88014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88015       };
88016     } catch (Dali::DaliException e) {
88017       {
88018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88019       };
88020     } catch (...) {
88021       {
88022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88023       };
88024     }
88025   }
88026
88027 }
88028
88029
88030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88031   void * jresult ;
88032   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88033   Dali::Actor result;
88034
88035   arg1 = (Dali::Toolkit::Popup *)jarg1;
88036   {
88037     try {
88038       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88039     } catch (std::out_of_range& e) {
88040       {
88041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88042       };
88043     } catch (std::exception& e) {
88044       {
88045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88046       };
88047     } catch (Dali::DaliException e) {
88048       {
88049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88050       };
88051     } catch (...) {
88052       {
88053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88054       };
88055     }
88056   }
88057
88058   jresult = new Dali::Actor((const Dali::Actor &)result);
88059   return jresult;
88060 }
88061
88062
88063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88064   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88065   Dali::Actor arg2 ;
88066   Dali::Actor *argp2 ;
88067
88068   arg1 = (Dali::Toolkit::Popup *)jarg1;
88069   argp2 = (Dali::Actor *)jarg2;
88070   if (!argp2) {
88071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88072     return ;
88073   }
88074   arg2 = *argp2;
88075   {
88076     try {
88077       (arg1)->SetFooter(arg2);
88078     } catch (std::out_of_range& e) {
88079       {
88080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88081       };
88082     } catch (std::exception& e) {
88083       {
88084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88085       };
88086     } catch (Dali::DaliException e) {
88087       {
88088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88089       };
88090     } catch (...) {
88091       {
88092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88093       };
88094     }
88095   }
88096
88097 }
88098
88099
88100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88101   void * jresult ;
88102   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88103   Dali::Actor result;
88104
88105   arg1 = (Dali::Toolkit::Popup *)jarg1;
88106   {
88107     try {
88108       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88109     } catch (std::out_of_range& e) {
88110       {
88111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88112       };
88113     } catch (std::exception& e) {
88114       {
88115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88116       };
88117     } catch (Dali::DaliException e) {
88118       {
88119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88120       };
88121     } catch (...) {
88122       {
88123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88124       };
88125     }
88126   }
88127
88128   jresult = new Dali::Actor((const Dali::Actor &)result);
88129   return jresult;
88130 }
88131
88132
88133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88134   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88135   Dali::Toolkit::Popup::DisplayState arg2 ;
88136
88137   arg1 = (Dali::Toolkit::Popup *)jarg1;
88138   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88139   {
88140     try {
88141       (arg1)->SetDisplayState(arg2);
88142     } catch (std::out_of_range& e) {
88143       {
88144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88145       };
88146     } catch (std::exception& e) {
88147       {
88148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88149       };
88150     } catch (Dali::DaliException e) {
88151       {
88152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88153       };
88154     } catch (...) {
88155       {
88156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88157       };
88158     }
88159   }
88160
88161 }
88162
88163
88164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88165   int jresult ;
88166   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88167   Dali::Toolkit::Popup::DisplayState result;
88168
88169   arg1 = (Dali::Toolkit::Popup *)jarg1;
88170   {
88171     try {
88172       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88173     } catch (std::out_of_range& e) {
88174       {
88175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88176       };
88177     } catch (std::exception& e) {
88178       {
88179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88180       };
88181     } catch (Dali::DaliException e) {
88182       {
88183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88184       };
88185     } catch (...) {
88186       {
88187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88188       };
88189     }
88190   }
88191
88192   jresult = (int)result;
88193   return jresult;
88194 }
88195
88196
88197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88198   void * jresult ;
88199   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88200   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88201
88202   arg1 = (Dali::Toolkit::Popup *)jarg1;
88203   {
88204     try {
88205       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88206     } catch (std::out_of_range& e) {
88207       {
88208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88209       };
88210     } catch (std::exception& e) {
88211       {
88212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88213       };
88214     } catch (Dali::DaliException e) {
88215       {
88216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88217       };
88218     } catch (...) {
88219       {
88220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88221       };
88222     }
88223   }
88224
88225   jresult = (void *)result;
88226   return jresult;
88227 }
88228
88229
88230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88231   void * jresult ;
88232   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88233   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88234
88235   arg1 = (Dali::Toolkit::Popup *)jarg1;
88236   {
88237     try {
88238       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88239     } catch (std::out_of_range& e) {
88240       {
88241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88242       };
88243     } catch (std::exception& e) {
88244       {
88245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88246       };
88247     } catch (Dali::DaliException e) {
88248       {
88249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88250       };
88251     } catch (...) {
88252       {
88253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88254       };
88255     }
88256   }
88257
88258   jresult = (void *)result;
88259   return jresult;
88260 }
88261
88262
88263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88264   void * jresult ;
88265   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88266   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88267
88268   arg1 = (Dali::Toolkit::Popup *)jarg1;
88269   {
88270     try {
88271       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88272     } catch (std::out_of_range& e) {
88273       {
88274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88275       };
88276     } catch (std::exception& e) {
88277       {
88278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88279       };
88280     } catch (Dali::DaliException e) {
88281       {
88282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88283       };
88284     } catch (...) {
88285       {
88286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88287       };
88288     }
88289   }
88290
88291   jresult = (void *)result;
88292   return jresult;
88293 }
88294
88295
88296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88297   void * jresult ;
88298   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88299   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88300
88301   arg1 = (Dali::Toolkit::Popup *)jarg1;
88302   {
88303     try {
88304       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88305     } catch (std::out_of_range& e) {
88306       {
88307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88308       };
88309     } catch (std::exception& e) {
88310       {
88311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88312       };
88313     } catch (Dali::DaliException e) {
88314       {
88315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88316       };
88317     } catch (...) {
88318       {
88319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88320       };
88321     }
88322   }
88323
88324   jresult = (void *)result;
88325   return jresult;
88326 }
88327
88328
88329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88330   void * jresult ;
88331   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88332   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88333
88334   arg1 = (Dali::Toolkit::Popup *)jarg1;
88335   {
88336     try {
88337       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88338     } catch (std::out_of_range& e) {
88339       {
88340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88341       };
88342     } catch (std::exception& e) {
88343       {
88344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88345       };
88346     } catch (Dali::DaliException e) {
88347       {
88348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88349       };
88350     } catch (...) {
88351       {
88352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88353       };
88354     }
88355   }
88356
88357   jresult = (void *)result;
88358   return jresult;
88359 }
88360
88361
88362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88363   int jresult ;
88364   int result;
88365
88366   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88367   jresult = (int)result;
88368   return jresult;
88369 }
88370
88371
88372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88373   int jresult ;
88374   int result;
88375
88376   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88377   jresult = (int)result;
88378   return jresult;
88379 }
88380
88381
88382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88383   int jresult ;
88384   int result;
88385
88386   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88387   jresult = (int)result;
88388   return jresult;
88389 }
88390
88391
88392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88393   int jresult ;
88394   int result;
88395
88396   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88397   jresult = (int)result;
88398   return jresult;
88399 }
88400
88401
88402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88403   int jresult ;
88404   int result;
88405
88406   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88407   jresult = (int)result;
88408   return jresult;
88409 }
88410
88411
88412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88413   int jresult ;
88414   int result;
88415
88416   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88417   jresult = (int)result;
88418   return jresult;
88419 }
88420
88421
88422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88423   int jresult ;
88424   int result;
88425
88426   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88427   jresult = (int)result;
88428   return jresult;
88429 }
88430
88431
88432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88433   int jresult ;
88434   int result;
88435
88436   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88437   jresult = (int)result;
88438   return jresult;
88439 }
88440
88441
88442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88443   int jresult ;
88444   int result;
88445
88446   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88447   jresult = (int)result;
88448   return jresult;
88449 }
88450
88451
88452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88453   void * jresult ;
88454   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88455
88456   {
88457     try {
88458       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88459     } catch (std::out_of_range& e) {
88460       {
88461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88462       };
88463     } catch (std::exception& e) {
88464       {
88465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88466       };
88467     } catch (Dali::DaliException e) {
88468       {
88469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88470       };
88471     } catch (...) {
88472       {
88473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88474       };
88475     }
88476   }
88477
88478   jresult = (void *)result;
88479   return jresult;
88480 }
88481
88482
88483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88484   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88485
88486   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88487   {
88488     try {
88489       delete arg1;
88490     } catch (std::out_of_range& e) {
88491       {
88492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88493       };
88494     } catch (std::exception& e) {
88495       {
88496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88497       };
88498     } catch (Dali::DaliException e) {
88499       {
88500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88501       };
88502     } catch (...) {
88503       {
88504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88505       };
88506     }
88507   }
88508
88509 }
88510
88511
88512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88513   void * jresult ;
88514   Dali::Toolkit::ProgressBar result;
88515
88516   {
88517     try {
88518       result = Dali::Toolkit::ProgressBar::New();
88519     } catch (std::out_of_range& e) {
88520       {
88521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88522       };
88523     } catch (std::exception& e) {
88524       {
88525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88526       };
88527     } catch (Dali::DaliException e) {
88528       {
88529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88530       };
88531     } catch (...) {
88532       {
88533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88534       };
88535     }
88536   }
88537
88538   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88539   return jresult;
88540 }
88541
88542
88543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88544   void * jresult ;
88545   Dali::Toolkit::ProgressBar *result = 0 ;
88546
88547   {
88548     try {
88549       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88550     } catch (std::out_of_range& e) {
88551       {
88552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88553       };
88554     } catch (std::exception& e) {
88555       {
88556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88557       };
88558     } catch (Dali::DaliException e) {
88559       {
88560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88561       };
88562     } catch (...) {
88563       {
88564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88565       };
88566     }
88567   }
88568
88569   jresult = (void *)result;
88570   return jresult;
88571 }
88572
88573
88574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88575   void * jresult ;
88576   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88577   Dali::Toolkit::ProgressBar *result = 0 ;
88578
88579   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88580   if (!arg1) {
88581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88582     return 0;
88583   }
88584   {
88585     try {
88586       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88587     } catch (std::out_of_range& e) {
88588       {
88589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88590       };
88591     } catch (std::exception& e) {
88592       {
88593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88594       };
88595     } catch (Dali::DaliException e) {
88596       {
88597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88598       };
88599     } catch (...) {
88600       {
88601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88602       };
88603     }
88604   }
88605
88606   jresult = (void *)result;
88607   return jresult;
88608 }
88609
88610
88611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88612   void * jresult ;
88613   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88614   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88615   Dali::Toolkit::ProgressBar *result = 0 ;
88616
88617   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88618   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88619   if (!arg2) {
88620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88621     return 0;
88622   }
88623   {
88624     try {
88625       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88626     } catch (std::out_of_range& e) {
88627       {
88628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88629       };
88630     } catch (std::exception& e) {
88631       {
88632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88633       };
88634     } catch (Dali::DaliException e) {
88635       {
88636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88637       };
88638     } catch (...) {
88639       {
88640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88641       };
88642     }
88643   }
88644
88645   jresult = (void *)result;
88646   return jresult;
88647 }
88648
88649
88650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88651   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88652
88653   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88654   {
88655     try {
88656       delete arg1;
88657     } catch (std::out_of_range& e) {
88658       {
88659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88660       };
88661     } catch (std::exception& e) {
88662       {
88663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88664       };
88665     } catch (Dali::DaliException e) {
88666       {
88667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88668       };
88669     } catch (...) {
88670       {
88671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88672       };
88673     }
88674   }
88675
88676 }
88677
88678
88679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88680   void * jresult ;
88681   Dali::BaseHandle arg1 ;
88682   Dali::BaseHandle *argp1 ;
88683   Dali::Toolkit::ProgressBar result;
88684
88685   argp1 = (Dali::BaseHandle *)jarg1;
88686   if (!argp1) {
88687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88688     return 0;
88689   }
88690   arg1 = *argp1;
88691   {
88692     try {
88693       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88694     } catch (std::out_of_range& e) {
88695       {
88696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88697       };
88698     } catch (std::exception& e) {
88699       {
88700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88701       };
88702     } catch (Dali::DaliException e) {
88703       {
88704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88705       };
88706     } catch (...) {
88707       {
88708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88709       };
88710     }
88711   }
88712
88713   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88714   return jresult;
88715 }
88716
88717
88718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
88719   void * jresult ;
88720   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88721   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
88722
88723   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88724   {
88725     try {
88726       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
88727     } catch (std::out_of_range& e) {
88728       {
88729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88730       };
88731     } catch (std::exception& e) {
88732       {
88733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88734       };
88735     } catch (Dali::DaliException e) {
88736       {
88737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88738       };
88739     } catch (...) {
88740       {
88741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88742       };
88743     }
88744   }
88745
88746   jresult = (void *)result;
88747   return jresult;
88748 }
88749
88750
88751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88752   void * jresult ;
88753   Dali::Toolkit::GaussianBlurView *result = 0 ;
88754
88755   {
88756     try {
88757       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88758     } catch (std::out_of_range& e) {
88759       {
88760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88761       };
88762     } catch (std::exception& e) {
88763       {
88764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88765       };
88766     } catch (Dali::DaliException e) {
88767       {
88768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88769       };
88770     } catch (...) {
88771       {
88772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88773       };
88774     }
88775   }
88776
88777   jresult = (void *)result;
88778   return jresult;
88779 }
88780
88781
88782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88783   void * jresult ;
88784   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88785   Dali::Toolkit::GaussianBlurView *result = 0 ;
88786
88787   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88788   if (!arg1) {
88789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88790     return 0;
88791   }
88792   {
88793     try {
88794       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88795     } catch (std::out_of_range& e) {
88796       {
88797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88798       };
88799     } catch (std::exception& e) {
88800       {
88801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88802       };
88803     } catch (Dali::DaliException e) {
88804       {
88805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88806       };
88807     } catch (...) {
88808       {
88809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88810       };
88811     }
88812   }
88813
88814   jresult = (void *)result;
88815   return jresult;
88816 }
88817
88818
88819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
88820   void * jresult ;
88821   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88822   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
88823   Dali::Toolkit::GaussianBlurView *result = 0 ;
88824
88825   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88826   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88827   if (!arg2) {
88828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88829     return 0;
88830   }
88831   {
88832     try {
88833       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
88834     } catch (std::out_of_range& e) {
88835       {
88836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88837       };
88838     } catch (std::exception& e) {
88839       {
88840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88841       };
88842     } catch (Dali::DaliException e) {
88843       {
88844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88845       };
88846     } catch (...) {
88847       {
88848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88849       };
88850     }
88851   }
88852
88853   jresult = (void *)result;
88854   return jresult;
88855 }
88856
88857
88858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
88859   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88860
88861   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88862   {
88863     try {
88864       delete arg1;
88865     } catch (std::out_of_range& e) {
88866       {
88867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88868       };
88869     } catch (std::exception& e) {
88870       {
88871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88872       };
88873     } catch (Dali::DaliException e) {
88874       {
88875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88876       };
88877     } catch (...) {
88878       {
88879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88880       };
88881     }
88882   }
88883
88884 }
88885
88886
88887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
88888   void * jresult ;
88889   Dali::BaseHandle arg1 ;
88890   Dali::BaseHandle *argp1 ;
88891   Dali::Toolkit::GaussianBlurView result;
88892
88893   argp1 = (Dali::BaseHandle *)jarg1;
88894   if (!argp1) {
88895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88896     return 0;
88897   }
88898   arg1 = *argp1;
88899   {
88900     try {
88901       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
88902     } catch (std::out_of_range& e) {
88903       {
88904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88905       };
88906     } catch (std::exception& e) {
88907       {
88908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88909       };
88910     } catch (Dali::DaliException e) {
88911       {
88912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88913       };
88914     } catch (...) {
88915       {
88916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88917       };
88918     }
88919   }
88920
88921   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88922   return jresult;
88923 }
88924
88925
88926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
88927   void * jresult ;
88928   Dali::Toolkit::GaussianBlurView result;
88929
88930   {
88931     try {
88932       result = Dali::Toolkit::GaussianBlurView::New();
88933     } catch (std::out_of_range& e) {
88934       {
88935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88936       };
88937     } catch (std::exception& e) {
88938       {
88939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88940       };
88941     } catch (Dali::DaliException e) {
88942       {
88943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88944       };
88945     } catch (...) {
88946       {
88947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88948       };
88949     }
88950   }
88951
88952   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88953   return jresult;
88954 }
88955
88956
88957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88958   void * jresult ;
88959   unsigned int arg1 ;
88960   float arg2 ;
88961   Dali::Pixel::Format arg3 ;
88962   float arg4 ;
88963   float arg5 ;
88964   bool arg6 ;
88965   Dali::Toolkit::GaussianBlurView result;
88966
88967   arg1 = (unsigned int)jarg1;
88968   arg2 = (float)jarg2;
88969   arg3 = (Dali::Pixel::Format)jarg3;
88970   arg4 = (float)jarg4;
88971   arg5 = (float)jarg5;
88972   arg6 = jarg6 ? true : false;
88973   {
88974     try {
88975       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88976     } catch (std::out_of_range& e) {
88977       {
88978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88979       };
88980     } catch (std::exception& e) {
88981       {
88982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88983       };
88984     } catch (Dali::DaliException e) {
88985       {
88986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88987       };
88988     } catch (...) {
88989       {
88990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88991       };
88992     }
88993   }
88994
88995   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88996   return jresult;
88997 }
88998
88999
89000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89001   void * jresult ;
89002   unsigned int arg1 ;
89003   float arg2 ;
89004   Dali::Pixel::Format arg3 ;
89005   float arg4 ;
89006   float arg5 ;
89007   Dali::Toolkit::GaussianBlurView result;
89008
89009   arg1 = (unsigned int)jarg1;
89010   arg2 = (float)jarg2;
89011   arg3 = (Dali::Pixel::Format)jarg3;
89012   arg4 = (float)jarg4;
89013   arg5 = (float)jarg5;
89014   {
89015     try {
89016       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89017     } catch (std::out_of_range& e) {
89018       {
89019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89020       };
89021     } catch (std::exception& e) {
89022       {
89023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89024       };
89025     } catch (Dali::DaliException e) {
89026       {
89027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89028       };
89029     } catch (...) {
89030       {
89031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89032       };
89033     }
89034   }
89035
89036   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89037   return jresult;
89038 }
89039
89040
89041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89042   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89043   Dali::Actor arg2 ;
89044   Dali::Actor *argp2 ;
89045
89046   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89047   argp2 = (Dali::Actor *)jarg2;
89048   if (!argp2) {
89049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89050     return ;
89051   }
89052   arg2 = *argp2;
89053   {
89054     try {
89055       (arg1)->Add(arg2);
89056     } catch (std::out_of_range& e) {
89057       {
89058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89059       };
89060     } catch (std::exception& e) {
89061       {
89062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89063       };
89064     } catch (Dali::DaliException e) {
89065       {
89066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89067       };
89068     } catch (...) {
89069       {
89070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89071       };
89072     }
89073   }
89074
89075 }
89076
89077
89078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89079   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89080   Dali::Actor arg2 ;
89081   Dali::Actor *argp2 ;
89082
89083   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89084   argp2 = (Dali::Actor *)jarg2;
89085   if (!argp2) {
89086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89087     return ;
89088   }
89089   arg2 = *argp2;
89090   {
89091     try {
89092       (arg1)->Remove(arg2);
89093     } catch (std::out_of_range& e) {
89094       {
89095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89096       };
89097     } catch (std::exception& e) {
89098       {
89099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89100       };
89101     } catch (Dali::DaliException e) {
89102       {
89103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89104       };
89105     } catch (...) {
89106       {
89107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89108       };
89109     }
89110   }
89111
89112 }
89113
89114
89115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89116   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89117
89118   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89119   {
89120     try {
89121       (arg1)->Activate();
89122     } catch (std::out_of_range& e) {
89123       {
89124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89125       };
89126     } catch (std::exception& e) {
89127       {
89128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89129       };
89130     } catch (Dali::DaliException e) {
89131       {
89132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89133       };
89134     } catch (...) {
89135       {
89136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89137       };
89138     }
89139   }
89140
89141 }
89142
89143
89144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89145   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89146
89147   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89148   {
89149     try {
89150       (arg1)->ActivateOnce();
89151     } catch (std::out_of_range& e) {
89152       {
89153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89154       };
89155     } catch (std::exception& e) {
89156       {
89157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89158       };
89159     } catch (Dali::DaliException e) {
89160       {
89161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89162       };
89163     } catch (...) {
89164       {
89165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89166       };
89167     }
89168   }
89169
89170 }
89171
89172
89173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89174   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89175
89176   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89177   {
89178     try {
89179       (arg1)->Deactivate();
89180     } catch (std::out_of_range& e) {
89181       {
89182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89183       };
89184     } catch (std::exception& e) {
89185       {
89186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89187       };
89188     } catch (Dali::DaliException e) {
89189       {
89190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89191       };
89192     } catch (...) {
89193       {
89194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89195       };
89196     }
89197   }
89198
89199 }
89200
89201
89202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89203   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89204   Dali::Image arg2 ;
89205   Dali::FrameBufferImage arg3 ;
89206   Dali::Image *argp2 ;
89207   Dali::FrameBufferImage *argp3 ;
89208
89209   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89210   argp2 = (Dali::Image *)jarg2;
89211   if (!argp2) {
89212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89213     return ;
89214   }
89215   arg2 = *argp2;
89216   argp3 = (Dali::FrameBufferImage *)jarg3;
89217   if (!argp3) {
89218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89219     return ;
89220   }
89221   arg3 = *argp3;
89222   {
89223     try {
89224       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89225     } catch (std::out_of_range& e) {
89226       {
89227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89228       };
89229     } catch (std::exception& e) {
89230       {
89231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89232       };
89233     } catch (Dali::DaliException e) {
89234       {
89235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89236       };
89237     } catch (...) {
89238       {
89239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89240       };
89241     }
89242   }
89243
89244 }
89245
89246
89247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89248   int jresult ;
89249   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89250   Dali::Property::Index result;
89251
89252   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89253   {
89254     try {
89255       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89256     } catch (std::out_of_range& e) {
89257       {
89258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89259       };
89260     } catch (std::exception& e) {
89261       {
89262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89263       };
89264     } catch (Dali::DaliException e) {
89265       {
89266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89267       };
89268     } catch (...) {
89269       {
89270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89271       };
89272     }
89273   }
89274
89275   jresult = result;
89276   return jresult;
89277 }
89278
89279
89280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89281   void * jresult ;
89282   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89283   Dali::FrameBufferImage result;
89284
89285   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89286   {
89287     try {
89288       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89289     } catch (std::out_of_range& e) {
89290       {
89291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89292       };
89293     } catch (std::exception& e) {
89294       {
89295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89296       };
89297     } catch (Dali::DaliException e) {
89298       {
89299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89300       };
89301     } catch (...) {
89302       {
89303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89304       };
89305     }
89306   }
89307
89308   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89309   return jresult;
89310 }
89311
89312
89313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89314   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89315   Dali::Vector4 *arg2 = 0 ;
89316
89317   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89318   arg2 = (Dali::Vector4 *)jarg2;
89319   if (!arg2) {
89320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89321     return ;
89322   }
89323   {
89324     try {
89325       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89326     } catch (std::out_of_range& e) {
89327       {
89328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89329       };
89330     } catch (std::exception& e) {
89331       {
89332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89333       };
89334     } catch (Dali::DaliException e) {
89335       {
89336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89337       };
89338     } catch (...) {
89339       {
89340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89341       };
89342     }
89343   }
89344
89345 }
89346
89347
89348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89349   void * jresult ;
89350   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89351   Dali::Vector4 result;
89352
89353   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89354   {
89355     try {
89356       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89357     } catch (std::out_of_range& e) {
89358       {
89359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89360       };
89361     } catch (std::exception& e) {
89362       {
89363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89364       };
89365     } catch (Dali::DaliException e) {
89366       {
89367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89368       };
89369     } catch (...) {
89370       {
89371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89372       };
89373     }
89374   }
89375
89376   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89377   return jresult;
89378 }
89379
89380
89381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89382   void * jresult ;
89383   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89384   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89385
89386   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89387   {
89388     try {
89389       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89390     } catch (std::out_of_range& e) {
89391       {
89392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89393       };
89394     } catch (std::exception& e) {
89395       {
89396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89397       };
89398     } catch (Dali::DaliException e) {
89399       {
89400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89401       };
89402     } catch (...) {
89403       {
89404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89405       };
89406     }
89407   }
89408
89409   jresult = (void *)result;
89410   return jresult;
89411 }
89412
89413
89414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89415   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89416
89417   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89418   {
89419     try {
89420       delete arg1;
89421     } catch (std::out_of_range& e) {
89422       {
89423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89424       };
89425     } catch (std::exception& e) {
89426       {
89427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89428       };
89429     } catch (Dali::DaliException e) {
89430       {
89431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89432       };
89433     } catch (...) {
89434       {
89435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89436       };
89437     }
89438   }
89439
89440 }
89441
89442
89443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89444   unsigned int jresult ;
89445   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89446   unsigned int result;
89447
89448   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89449   {
89450     try {
89451       result = (unsigned int)(arg1)->GetNumberOfPages();
89452     } catch (std::out_of_range& e) {
89453       {
89454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89455       };
89456     } catch (std::exception& e) {
89457       {
89458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89459       };
89460     } catch (Dali::DaliException e) {
89461       {
89462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89463       };
89464     } catch (...) {
89465       {
89466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89467       };
89468     }
89469   }
89470
89471   jresult = result;
89472   return jresult;
89473 }
89474
89475
89476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89477   void * jresult ;
89478   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89479   unsigned int arg2 ;
89480   Dali::Texture result;
89481
89482   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89483   arg2 = (unsigned int)jarg2;
89484   {
89485     try {
89486       result = (arg1)->NewPage(arg2);
89487     } catch (std::out_of_range& e) {
89488       {
89489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89490       };
89491     } catch (std::exception& e) {
89492       {
89493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89494       };
89495     } catch (Dali::DaliException e) {
89496       {
89497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89498       };
89499     } catch (...) {
89500       {
89501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89502       };
89503     }
89504   }
89505
89506   jresult = new Dali::Texture((const Dali::Texture &)result);
89507   return jresult;
89508 }
89509
89510
89511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89512   int jresult ;
89513   int result;
89514
89515   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89516   jresult = (int)result;
89517   return jresult;
89518 }
89519
89520
89521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89522   int jresult ;
89523   int result;
89524
89525   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89526   jresult = (int)result;
89527   return jresult;
89528 }
89529
89530
89531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89532   int jresult ;
89533   int result;
89534
89535   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89536   jresult = (int)result;
89537   return jresult;
89538 }
89539
89540
89541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89542   void * jresult ;
89543   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89544
89545   {
89546     try {
89547       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89548     } catch (std::out_of_range& e) {
89549       {
89550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89551       };
89552     } catch (std::exception& e) {
89553       {
89554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89555       };
89556     } catch (Dali::DaliException e) {
89557       {
89558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89559       };
89560     } catch (...) {
89561       {
89562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89563       };
89564     }
89565   }
89566
89567   jresult = (void *)result;
89568   return jresult;
89569 }
89570
89571
89572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89573   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89574
89575   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89576   {
89577     try {
89578       delete arg1;
89579     } catch (std::out_of_range& e) {
89580       {
89581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89582       };
89583     } catch (std::exception& e) {
89584       {
89585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89586       };
89587     } catch (Dali::DaliException e) {
89588       {
89589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89590       };
89591     } catch (...) {
89592       {
89593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89594       };
89595     }
89596   }
89597
89598 }
89599
89600
89601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89602   void * jresult ;
89603   Dali::Toolkit::PageTurnView *result = 0 ;
89604
89605   {
89606     try {
89607       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89608     } catch (std::out_of_range& e) {
89609       {
89610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89611       };
89612     } catch (std::exception& e) {
89613       {
89614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89615       };
89616     } catch (Dali::DaliException e) {
89617       {
89618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89619       };
89620     } catch (...) {
89621       {
89622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89623       };
89624     }
89625   }
89626
89627   jresult = (void *)result;
89628   return jresult;
89629 }
89630
89631
89632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89633   void * jresult ;
89634   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89635   Dali::Toolkit::PageTurnView *result = 0 ;
89636
89637   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89638   if (!arg1) {
89639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89640     return 0;
89641   }
89642   {
89643     try {
89644       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89645     } catch (std::out_of_range& e) {
89646       {
89647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89648       };
89649     } catch (std::exception& e) {
89650       {
89651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89652       };
89653     } catch (Dali::DaliException e) {
89654       {
89655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89656       };
89657     } catch (...) {
89658       {
89659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89660       };
89661     }
89662   }
89663
89664   jresult = (void *)result;
89665   return jresult;
89666 }
89667
89668
89669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89670   void * jresult ;
89671   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89672   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89673   Dali::Toolkit::PageTurnView *result = 0 ;
89674
89675   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89676   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89677   if (!arg2) {
89678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89679     return 0;
89680   }
89681   {
89682     try {
89683       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89684     } catch (std::out_of_range& e) {
89685       {
89686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89687       };
89688     } catch (std::exception& e) {
89689       {
89690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89691       };
89692     } catch (Dali::DaliException e) {
89693       {
89694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89695       };
89696     } catch (...) {
89697       {
89698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89699       };
89700     }
89701   }
89702
89703   jresult = (void *)result;
89704   return jresult;
89705 }
89706
89707
89708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89709   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89710
89711   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89712   {
89713     try {
89714       delete arg1;
89715     } catch (std::out_of_range& e) {
89716       {
89717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89718       };
89719     } catch (std::exception& e) {
89720       {
89721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89722       };
89723     } catch (Dali::DaliException e) {
89724       {
89725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89726       };
89727     } catch (...) {
89728       {
89729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89730       };
89731     }
89732   }
89733
89734 }
89735
89736
89737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
89738   void * jresult ;
89739   Dali::BaseHandle arg1 ;
89740   Dali::BaseHandle *argp1 ;
89741   Dali::Toolkit::PageTurnView result;
89742
89743   argp1 = (Dali::BaseHandle *)jarg1;
89744   if (!argp1) {
89745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89746     return 0;
89747   }
89748   arg1 = *argp1;
89749   {
89750     try {
89751       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89752     } catch (std::out_of_range& e) {
89753       {
89754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89755       };
89756     } catch (std::exception& e) {
89757       {
89758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89759       };
89760     } catch (Dali::DaliException e) {
89761       {
89762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89763       };
89764     } catch (...) {
89765       {
89766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89767       };
89768     }
89769   }
89770
89771   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89772   return jresult;
89773 }
89774
89775
89776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89777   void * jresult ;
89778   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89779   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89780
89781   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89782   {
89783     try {
89784       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89785     } catch (std::out_of_range& e) {
89786       {
89787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89788       };
89789     } catch (std::exception& e) {
89790       {
89791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89792       };
89793     } catch (Dali::DaliException e) {
89794       {
89795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89796       };
89797     } catch (...) {
89798       {
89799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89800       };
89801     }
89802   }
89803
89804   jresult = (void *)result;
89805   return jresult;
89806 }
89807
89808
89809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
89810   void * jresult ;
89811   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89812   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89813
89814   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89815   {
89816     try {
89817       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
89818     } catch (std::out_of_range& e) {
89819       {
89820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89821       };
89822     } catch (std::exception& e) {
89823       {
89824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89825       };
89826     } catch (Dali::DaliException e) {
89827       {
89828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89829       };
89830     } catch (...) {
89831       {
89832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89833       };
89834     }
89835   }
89836
89837   jresult = (void *)result;
89838   return jresult;
89839 }
89840
89841
89842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
89843   void * jresult ;
89844   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89845   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89846
89847   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89848   {
89849     try {
89850       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
89851     } catch (std::out_of_range& e) {
89852       {
89853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89854       };
89855     } catch (std::exception& e) {
89856       {
89857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89858       };
89859     } catch (Dali::DaliException e) {
89860       {
89861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89862       };
89863     } catch (...) {
89864       {
89865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89866       };
89867     }
89868   }
89869
89870   jresult = (void *)result;
89871   return jresult;
89872 }
89873
89874
89875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
89876   void * jresult ;
89877   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89878   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89879
89880   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89881   {
89882     try {
89883       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
89884     } catch (std::out_of_range& e) {
89885       {
89886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89887       };
89888     } catch (std::exception& e) {
89889       {
89890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89891       };
89892     } catch (Dali::DaliException e) {
89893       {
89894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89895       };
89896     } catch (...) {
89897       {
89898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89899       };
89900     }
89901   }
89902
89903   jresult = (void *)result;
89904   return jresult;
89905 }
89906
89907
89908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
89909   void * jresult ;
89910   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89911
89912   {
89913     try {
89914       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
89915     } catch (std::out_of_range& e) {
89916       {
89917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89918       };
89919     } catch (std::exception& e) {
89920       {
89921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89922       };
89923     } catch (Dali::DaliException e) {
89924       {
89925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89926       };
89927     } catch (...) {
89928       {
89929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89930       };
89931     }
89932   }
89933
89934   jresult = (void *)result;
89935   return jresult;
89936 }
89937
89938
89939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89940   void * jresult ;
89941   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89942   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89943
89944   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89945   if (!arg1) {
89946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89947     return 0;
89948   }
89949   {
89950     try {
89951       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89952     } catch (std::out_of_range& e) {
89953       {
89954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89955       };
89956     } catch (std::exception& e) {
89957       {
89958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89959       };
89960     } catch (Dali::DaliException e) {
89961       {
89962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89963       };
89964     } catch (...) {
89965       {
89966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89967       };
89968     }
89969   }
89970
89971   jresult = (void *)result;
89972   return jresult;
89973 }
89974
89975
89976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89977   void * jresult ;
89978   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89979   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89980   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89981
89982   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89983   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89984   if (!arg2) {
89985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89986     return 0;
89987   }
89988   {
89989     try {
89990       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89991     } catch (std::out_of_range& e) {
89992       {
89993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89994       };
89995     } catch (std::exception& e) {
89996       {
89997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89998       };
89999     } catch (Dali::DaliException e) {
90000       {
90001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90002       };
90003     } catch (...) {
90004       {
90005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90006       };
90007     }
90008   }
90009
90010   jresult = (void *)result;
90011   return jresult;
90012 }
90013
90014
90015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90016   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90017
90018   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90019   {
90020     try {
90021       delete arg1;
90022     } catch (std::out_of_range& e) {
90023       {
90024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90025       };
90026     } catch (std::exception& e) {
90027       {
90028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90029       };
90030     } catch (Dali::DaliException e) {
90031       {
90032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90033       };
90034     } catch (...) {
90035       {
90036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90037       };
90038     }
90039   }
90040
90041 }
90042
90043
90044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90045   void * jresult ;
90046   Dali::Toolkit::PageFactory *arg1 = 0 ;
90047   Dali::Vector2 *arg2 = 0 ;
90048   Dali::Toolkit::PageTurnLandscapeView result;
90049
90050   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90051   if (!arg1) {
90052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90053     return 0;
90054   }
90055   arg2 = (Dali::Vector2 *)jarg2;
90056   if (!arg2) {
90057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90058     return 0;
90059   }
90060   {
90061     try {
90062       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90063     } catch (std::out_of_range& e) {
90064       {
90065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90066       };
90067     } catch (std::exception& e) {
90068       {
90069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90070       };
90071     } catch (Dali::DaliException e) {
90072       {
90073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90074       };
90075     } catch (...) {
90076       {
90077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90078       };
90079     }
90080   }
90081
90082   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90083   return jresult;
90084 }
90085
90086
90087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90088   void * jresult ;
90089   Dali::BaseHandle arg1 ;
90090   Dali::BaseHandle *argp1 ;
90091   Dali::Toolkit::PageTurnLandscapeView result;
90092
90093   argp1 = (Dali::BaseHandle *)jarg1;
90094   if (!argp1) {
90095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90096     return 0;
90097   }
90098   arg1 = *argp1;
90099   {
90100     try {
90101       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90102     } catch (std::out_of_range& e) {
90103       {
90104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90105       };
90106     } catch (std::exception& e) {
90107       {
90108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90109       };
90110     } catch (Dali::DaliException e) {
90111       {
90112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90113       };
90114     } catch (...) {
90115       {
90116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90117       };
90118     }
90119   }
90120
90121   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90122   return jresult;
90123 }
90124
90125
90126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90127   void * jresult ;
90128   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90129
90130   {
90131     try {
90132       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90133     } catch (std::out_of_range& e) {
90134       {
90135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90136       };
90137     } catch (std::exception& e) {
90138       {
90139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90140       };
90141     } catch (Dali::DaliException e) {
90142       {
90143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90144       };
90145     } catch (...) {
90146       {
90147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90148       };
90149     }
90150   }
90151
90152   jresult = (void *)result;
90153   return jresult;
90154 }
90155
90156
90157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90158   void * jresult ;
90159   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90160   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90161
90162   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90163   if (!arg1) {
90164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90165     return 0;
90166   }
90167   {
90168     try {
90169       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90170     } catch (std::out_of_range& e) {
90171       {
90172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90173       };
90174     } catch (std::exception& e) {
90175       {
90176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90177       };
90178     } catch (Dali::DaliException e) {
90179       {
90180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90181       };
90182     } catch (...) {
90183       {
90184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90185       };
90186     }
90187   }
90188
90189   jresult = (void *)result;
90190   return jresult;
90191 }
90192
90193
90194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90195   void * jresult ;
90196   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90197   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90198   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90199
90200   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90201   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90202   if (!arg2) {
90203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90204     return 0;
90205   }
90206   {
90207     try {
90208       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90209     } catch (std::out_of_range& e) {
90210       {
90211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90212       };
90213     } catch (std::exception& e) {
90214       {
90215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90216       };
90217     } catch (Dali::DaliException e) {
90218       {
90219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90220       };
90221     } catch (...) {
90222       {
90223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90224       };
90225     }
90226   }
90227
90228   jresult = (void *)result;
90229   return jresult;
90230 }
90231
90232
90233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90234   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90235
90236   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90237   {
90238     try {
90239       delete arg1;
90240     } catch (std::out_of_range& e) {
90241       {
90242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90243       };
90244     } catch (std::exception& e) {
90245       {
90246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90247       };
90248     } catch (Dali::DaliException e) {
90249       {
90250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90251       };
90252     } catch (...) {
90253       {
90254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90255       };
90256     }
90257   }
90258
90259 }
90260
90261
90262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90263   void * jresult ;
90264   Dali::Toolkit::PageFactory *arg1 = 0 ;
90265   Dali::Vector2 *arg2 = 0 ;
90266   Dali::Toolkit::PageTurnPortraitView result;
90267
90268   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90269   if (!arg1) {
90270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90271     return 0;
90272   }
90273   arg2 = (Dali::Vector2 *)jarg2;
90274   if (!arg2) {
90275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90276     return 0;
90277   }
90278   {
90279     try {
90280       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90281     } catch (std::out_of_range& e) {
90282       {
90283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90284       };
90285     } catch (std::exception& e) {
90286       {
90287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90288       };
90289     } catch (Dali::DaliException e) {
90290       {
90291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90292       };
90293     } catch (...) {
90294       {
90295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90296       };
90297     }
90298   }
90299
90300   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90301   return jresult;
90302 }
90303
90304
90305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90306   void * jresult ;
90307   Dali::BaseHandle arg1 ;
90308   Dali::BaseHandle *argp1 ;
90309   Dali::Toolkit::PageTurnPortraitView result;
90310
90311   argp1 = (Dali::BaseHandle *)jarg1;
90312   if (!argp1) {
90313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90314     return 0;
90315   }
90316   arg1 = *argp1;
90317   {
90318     try {
90319       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90320     } catch (std::out_of_range& e) {
90321       {
90322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90323       };
90324     } catch (std::exception& e) {
90325       {
90326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90327       };
90328     } catch (Dali::DaliException e) {
90329       {
90330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90331       };
90332     } catch (...) {
90333       {
90334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90335       };
90336     }
90337   }
90338
90339   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90340   return jresult;
90341 }
90342
90343
90344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90345   int jresult ;
90346   int result;
90347
90348   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90349   jresult = (int)result;
90350   return jresult;
90351 }
90352
90353
90354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90355   int jresult ;
90356   int result;
90357
90358   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90359   jresult = (int)result;
90360   return jresult;
90361 }
90362
90363
90364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90365   int jresult ;
90366   int result;
90367
90368   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90369   jresult = (int)result;
90370   return jresult;
90371 }
90372
90373
90374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90375   void * jresult ;
90376   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90377
90378   {
90379     try {
90380       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90381     } catch (std::out_of_range& e) {
90382       {
90383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90384       };
90385     } catch (std::exception& e) {
90386       {
90387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90388       };
90389     } catch (Dali::DaliException e) {
90390       {
90391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90392       };
90393     } catch (...) {
90394       {
90395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90396       };
90397     }
90398   }
90399
90400   jresult = (void *)result;
90401   return jresult;
90402 }
90403
90404
90405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90406   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90407
90408   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90409   {
90410     try {
90411       delete arg1;
90412     } catch (std::out_of_range& e) {
90413       {
90414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90415       };
90416     } catch (std::exception& e) {
90417       {
90418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90419       };
90420     } catch (Dali::DaliException e) {
90421       {
90422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90423       };
90424     } catch (...) {
90425       {
90426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90427       };
90428     }
90429   }
90430
90431 }
90432
90433
90434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90435   void * jresult ;
90436   Dali::Toolkit::ToggleButton *result = 0 ;
90437
90438   {
90439     try {
90440       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90441     } catch (std::out_of_range& e) {
90442       {
90443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90444       };
90445     } catch (std::exception& e) {
90446       {
90447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90448       };
90449     } catch (Dali::DaliException e) {
90450       {
90451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90452       };
90453     } catch (...) {
90454       {
90455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90456       };
90457     }
90458   }
90459
90460   jresult = (void *)result;
90461   return jresult;
90462 }
90463
90464
90465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90466   void * jresult ;
90467   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90468   Dali::Toolkit::ToggleButton *result = 0 ;
90469
90470   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90471   if (!arg1) {
90472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90473     return 0;
90474   }
90475   {
90476     try {
90477       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90478     } catch (std::out_of_range& e) {
90479       {
90480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90481       };
90482     } catch (std::exception& e) {
90483       {
90484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90485       };
90486     } catch (Dali::DaliException e) {
90487       {
90488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90489       };
90490     } catch (...) {
90491       {
90492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90493       };
90494     }
90495   }
90496
90497   jresult = (void *)result;
90498   return jresult;
90499 }
90500
90501
90502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90503   void * jresult ;
90504   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90505   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90506   Dali::Toolkit::ToggleButton *result = 0 ;
90507
90508   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90509   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90510   if (!arg2) {
90511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90512     return 0;
90513   }
90514   {
90515     try {
90516       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90517     } catch (std::out_of_range& e) {
90518       {
90519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90520       };
90521     } catch (std::exception& e) {
90522       {
90523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90524       };
90525     } catch (Dali::DaliException e) {
90526       {
90527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90528       };
90529     } catch (...) {
90530       {
90531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90532       };
90533     }
90534   }
90535
90536   jresult = (void *)result;
90537   return jresult;
90538 }
90539
90540
90541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90542   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90543
90544   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90545   {
90546     try {
90547       delete arg1;
90548     } catch (std::out_of_range& e) {
90549       {
90550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90551       };
90552     } catch (std::exception& e) {
90553       {
90554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90555       };
90556     } catch (Dali::DaliException e) {
90557       {
90558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90559       };
90560     } catch (...) {
90561       {
90562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90563       };
90564     }
90565   }
90566
90567 }
90568
90569
90570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90571   void * jresult ;
90572   Dali::Toolkit::ToggleButton result;
90573
90574   {
90575     try {
90576       result = Dali::Toolkit::ToggleButton::New();
90577     } catch (std::out_of_range& e) {
90578       {
90579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90580       };
90581     } catch (std::exception& e) {
90582       {
90583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90584       };
90585     } catch (Dali::DaliException e) {
90586       {
90587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90588       };
90589     } catch (...) {
90590       {
90591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90592       };
90593     }
90594   }
90595
90596   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90597   return jresult;
90598 }
90599
90600
90601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90602   void * jresult ;
90603   Dali::BaseHandle arg1 ;
90604   Dali::BaseHandle *argp1 ;
90605   Dali::Toolkit::ToggleButton result;
90606
90607   argp1 = (Dali::BaseHandle *)jarg1;
90608   if (!argp1) {
90609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90610     return 0;
90611   }
90612   arg1 = *argp1;
90613   {
90614     try {
90615       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90616     } catch (std::out_of_range& e) {
90617       {
90618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90619       };
90620     } catch (std::exception& e) {
90621       {
90622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90623       };
90624     } catch (Dali::DaliException e) {
90625       {
90626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90627       };
90628     } catch (...) {
90629       {
90630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90631       };
90632     }
90633   }
90634
90635   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90636   return jresult;
90637 }
90638
90639
90640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90641   void * jresult ;
90642   Dali::Toolkit::Visual::Base *result = 0 ;
90643
90644   {
90645     try {
90646       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90647     } catch (std::out_of_range& e) {
90648       {
90649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90650       };
90651     } catch (std::exception& e) {
90652       {
90653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90654       };
90655     } catch (Dali::DaliException e) {
90656       {
90657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90658       };
90659     } catch (...) {
90660       {
90661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90662       };
90663     }
90664   }
90665
90666   jresult = (void *)result;
90667   return jresult;
90668 }
90669
90670
90671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90672   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90673
90674   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90675   {
90676     try {
90677       delete arg1;
90678     } catch (std::out_of_range& e) {
90679       {
90680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90681       };
90682     } catch (std::exception& e) {
90683       {
90684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90685       };
90686     } catch (Dali::DaliException e) {
90687       {
90688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90689       };
90690     } catch (...) {
90691       {
90692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90693       };
90694     }
90695   }
90696
90697 }
90698
90699
90700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90701   void * jresult ;
90702   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90703   Dali::Toolkit::Visual::Base *result = 0 ;
90704
90705   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90706   if (!arg1) {
90707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90708     return 0;
90709   }
90710   {
90711     try {
90712       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
90713     } catch (std::out_of_range& e) {
90714       {
90715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90716       };
90717     } catch (std::exception& e) {
90718       {
90719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90720       };
90721     } catch (Dali::DaliException e) {
90722       {
90723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90724       };
90725     } catch (...) {
90726       {
90727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90728       };
90729     }
90730   }
90731
90732   jresult = (void *)result;
90733   return jresult;
90734 }
90735
90736
90737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
90738   void * jresult ;
90739   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90740   Dali::Toolkit::Visual::Base *arg2 = 0 ;
90741   Dali::Toolkit::Visual::Base *result = 0 ;
90742
90743   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90744   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90745   if (!arg2) {
90746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90747     return 0;
90748   }
90749   {
90750     try {
90751       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90752     } catch (std::out_of_range& e) {
90753       {
90754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90755       };
90756     } catch (std::exception& e) {
90757       {
90758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90759       };
90760     } catch (Dali::DaliException e) {
90761       {
90762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90763       };
90764     } catch (...) {
90765       {
90766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90767       };
90768     }
90769   }
90770
90771   jresult = (void *)result;
90772   return jresult;
90773 }
90774
90775
90776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90777   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90778   std::string *arg2 = 0 ;
90779
90780   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90781   if (!jarg2) {
90782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90783     return ;
90784   }
90785   std::string arg2_str(jarg2);
90786   arg2 = &arg2_str;
90787   {
90788     try {
90789       (arg1)->SetName((std::string const &)*arg2);
90790     } catch (std::out_of_range& e) {
90791       {
90792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90793       };
90794     } catch (std::exception& e) {
90795       {
90796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90797       };
90798     } catch (Dali::DaliException e) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90801       };
90802     } catch (...) {
90803       {
90804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90805       };
90806     }
90807   }
90808
90809
90810   //argout typemap for const std::string&
90811
90812 }
90813
90814
90815 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
90816   char * jresult ;
90817   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90818   std::string *result = 0 ;
90819
90820   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90821   {
90822     try {
90823       result = (std::string *) &(arg1)->GetName();
90824     } catch (std::out_of_range& e) {
90825       {
90826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90827       };
90828     } catch (std::exception& e) {
90829       {
90830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90831       };
90832     } catch (Dali::DaliException e) {
90833       {
90834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90835       };
90836     } catch (...) {
90837       {
90838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90839       };
90840     }
90841   }
90842
90843   jresult = SWIG_csharp_string_callback(result->c_str());
90844   return jresult;
90845 }
90846
90847
90848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
90849   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90850   Dali::Property::Map *arg2 = 0 ;
90851   Dali::Size arg3 ;
90852   Dali::Size *argp3 ;
90853
90854   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90855   arg2 = (Dali::Property::Map *)jarg2;
90856   if (!arg2) {
90857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90858     return ;
90859   }
90860   argp3 = (Dali::Size *)jarg3;
90861   if (!argp3) {
90862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
90863     return ;
90864   }
90865   arg3 = *argp3;
90866   {
90867     try {
90868       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
90869     } catch (std::out_of_range& e) {
90870       {
90871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90872       };
90873     } catch (std::exception& e) {
90874       {
90875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90876       };
90877     } catch (Dali::DaliException e) {
90878       {
90879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90880       };
90881     } catch (...) {
90882       {
90883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90884       };
90885     }
90886   }
90887
90888 }
90889
90890
90891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
90892   float jresult ;
90893   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90894   float arg2 ;
90895   float result;
90896
90897   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90898   arg2 = (float)jarg2;
90899   {
90900     try {
90901       result = (float)(arg1)->GetHeightForWidth(arg2);
90902     } catch (std::out_of_range& e) {
90903       {
90904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90905       };
90906     } catch (std::exception& e) {
90907       {
90908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90909       };
90910     } catch (Dali::DaliException e) {
90911       {
90912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90913       };
90914     } catch (...) {
90915       {
90916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90917       };
90918     }
90919   }
90920
90921   jresult = result;
90922   return jresult;
90923 }
90924
90925
90926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
90927   float jresult ;
90928   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90929   float arg2 ;
90930   float result;
90931
90932   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90933   arg2 = (float)jarg2;
90934   {
90935     try {
90936       result = (float)(arg1)->GetWidthForHeight(arg2);
90937     } catch (std::out_of_range& e) {
90938       {
90939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90940       };
90941     } catch (std::exception& e) {
90942       {
90943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90944       };
90945     } catch (Dali::DaliException e) {
90946       {
90947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90948       };
90949     } catch (...) {
90950       {
90951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90952       };
90953     }
90954   }
90955
90956   jresult = result;
90957   return jresult;
90958 }
90959
90960
90961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90962   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90963   Dali::Vector2 *arg2 = 0 ;
90964
90965   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90966   arg2 = (Dali::Vector2 *)jarg2;
90967   if (!arg2) {
90968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90969     return ;
90970   }
90971   {
90972     try {
90973       (arg1)->GetNaturalSize(*arg2);
90974     } catch (std::out_of_range& e) {
90975       {
90976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90977       };
90978     } catch (std::exception& e) {
90979       {
90980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90981       };
90982     } catch (Dali::DaliException e) {
90983       {
90984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90985       };
90986     } catch (...) {
90987       {
90988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90989       };
90990     }
90991   }
90992
90993 }
90994
90995
90996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90997   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90998   float arg2 ;
90999
91000   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91001   arg2 = (int)jarg2;
91002   {
91003     try {
91004       (arg1)->SetDepthIndex(arg2);
91005     } catch (std::out_of_range& e) {
91006       {
91007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91008       };
91009     } catch (std::exception& e) {
91010       {
91011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91012       };
91013     } catch (Dali::DaliException e) {
91014       {
91015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91016       };
91017     } catch (...) {
91018       {
91019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91020       };
91021     }
91022   }
91023
91024 }
91025
91026
91027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91028   int jresult ;
91029   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91030   int result;
91031
91032   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91033   {
91034     try {
91035       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91036     } catch (std::out_of_range& e) {
91037       {
91038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91039       };
91040     } catch (std::exception& e) {
91041       {
91042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91043       };
91044     } catch (Dali::DaliException e) {
91045       {
91046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91047       };
91048     } catch (...) {
91049       {
91050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91051       };
91052     }
91053   }
91054
91055   jresult = result;
91056   return jresult;
91057 }
91058
91059
91060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91061   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91062   Dali::Property::Map *arg2 = 0 ;
91063
91064   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91065   arg2 = (Dali::Property::Map *)jarg2;
91066   if (!arg2) {
91067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91068     return ;
91069   }
91070   {
91071     try {
91072       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91073     } catch (std::out_of_range& e) {
91074       {
91075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91076       };
91077     } catch (std::exception& e) {
91078       {
91079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91080       };
91081     } catch (Dali::DaliException e) {
91082       {
91083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91084       };
91085     } catch (...) {
91086       {
91087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91088       };
91089     }
91090   }
91091
91092 }
91093
91094
91095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91096   void * jresult ;
91097   Dali::Toolkit::VisualFactory result;
91098
91099   {
91100     try {
91101       result = Dali::Toolkit::VisualFactory::Get();
91102     } catch (std::out_of_range& e) {
91103       {
91104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91105       };
91106     } catch (std::exception& e) {
91107       {
91108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91109       };
91110     } catch (Dali::DaliException e) {
91111       {
91112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91113       };
91114     } catch (...) {
91115       {
91116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91117       };
91118     }
91119   }
91120
91121   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91122   return jresult;
91123 }
91124
91125
91126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91127   void * jresult ;
91128   Dali::Toolkit::VisualFactory *result = 0 ;
91129
91130   {
91131     try {
91132       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91133     } catch (std::out_of_range& e) {
91134       {
91135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91136       };
91137     } catch (std::exception& e) {
91138       {
91139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91140       };
91141     } catch (Dali::DaliException e) {
91142       {
91143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91144       };
91145     } catch (...) {
91146       {
91147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91148       };
91149     }
91150   }
91151
91152   jresult = (void *)result;
91153   return jresult;
91154 }
91155
91156
91157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91158   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91159
91160   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91161   {
91162     try {
91163       delete arg1;
91164     } catch (std::out_of_range& e) {
91165       {
91166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91167       };
91168     } catch (std::exception& e) {
91169       {
91170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91171       };
91172     } catch (Dali::DaliException e) {
91173       {
91174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91175       };
91176     } catch (...) {
91177       {
91178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91179       };
91180     }
91181   }
91182
91183 }
91184
91185
91186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91187   void * jresult ;
91188   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91189   Dali::Toolkit::VisualFactory *result = 0 ;
91190
91191   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91192   if (!arg1) {
91193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91194     return 0;
91195   }
91196   {
91197     try {
91198       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91199     } catch (std::out_of_range& e) {
91200       {
91201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91202       };
91203     } catch (std::exception& e) {
91204       {
91205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91206       };
91207     } catch (Dali::DaliException e) {
91208       {
91209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91210       };
91211     } catch (...) {
91212       {
91213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91214       };
91215     }
91216   }
91217
91218   jresult = (void *)result;
91219   return jresult;
91220 }
91221
91222
91223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91224   void * jresult ;
91225   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91226   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91227   Dali::Toolkit::VisualFactory *result = 0 ;
91228
91229   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91230   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91231   if (!arg2) {
91232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91233     return 0;
91234   }
91235   {
91236     try {
91237       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91238     } catch (std::out_of_range& e) {
91239       {
91240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91241       };
91242     } catch (std::exception& e) {
91243       {
91244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91245       };
91246     } catch (Dali::DaliException e) {
91247       {
91248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91249       };
91250     } catch (...) {
91251       {
91252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91253       };
91254     }
91255   }
91256
91257   jresult = (void *)result;
91258   return jresult;
91259 }
91260
91261
91262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91263   void * jresult ;
91264   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91265   Dali::Property::Map *arg2 = 0 ;
91266   Dali::Toolkit::Visual::Base result;
91267
91268   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91269   arg2 = (Dali::Property::Map *)jarg2;
91270   if (!arg2) {
91271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91272     return 0;
91273   }
91274   {
91275     try {
91276       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91277     } catch (std::out_of_range& e) {
91278       {
91279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91280       };
91281     } catch (std::exception& e) {
91282       {
91283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91284       };
91285     } catch (Dali::DaliException e) {
91286       {
91287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91288       };
91289     } catch (...) {
91290       {
91291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91292       };
91293     }
91294   }
91295
91296   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91297   return jresult;
91298 }
91299
91300
91301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91302   void * jresult ;
91303   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91304   Dali::Image *arg2 = 0 ;
91305   Dali::Toolkit::Visual::Base result;
91306
91307   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91308   arg2 = (Dali::Image *)jarg2;
91309   if (!arg2) {
91310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91311     return 0;
91312   }
91313   {
91314     try {
91315       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91316     } catch (std::out_of_range& e) {
91317       {
91318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91319       };
91320     } catch (std::exception& e) {
91321       {
91322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91323       };
91324     } catch (Dali::DaliException e) {
91325       {
91326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91327       };
91328     } catch (...) {
91329       {
91330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91331       };
91332     }
91333   }
91334
91335   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91336   return jresult;
91337 }
91338
91339
91340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91341   void * jresult ;
91342   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91343   std::string *arg2 = 0 ;
91344   Dali::ImageDimensions arg3 ;
91345   Dali::ImageDimensions *argp3 ;
91346   Dali::Toolkit::Visual::Base result;
91347
91348   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91349   if (!jarg2) {
91350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91351     return 0;
91352   }
91353   std::string arg2_str(jarg2);
91354   arg2 = &arg2_str;
91355   argp3 = (Dali::ImageDimensions *)jarg3;
91356   if (!argp3) {
91357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91358     return 0;
91359   }
91360   arg3 = *argp3;
91361   {
91362     try {
91363       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91364     } catch (std::out_of_range& e) {
91365       {
91366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91367       };
91368     } catch (std::exception& e) {
91369       {
91370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91371       };
91372     } catch (Dali::DaliException e) {
91373       {
91374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91375       };
91376     } catch (...) {
91377       {
91378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91379       };
91380     }
91381   }
91382
91383   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91384
91385   //argout typemap for const std::string&
91386
91387   return jresult;
91388 }
91389
91390
91391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91392   void * jresult ;
91393   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91394
91395   {
91396     try {
91397       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91398     } catch (std::out_of_range& e) {
91399       {
91400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91401       };
91402     } catch (std::exception& e) {
91403       {
91404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91405       };
91406     } catch (Dali::DaliException e) {
91407       {
91408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91409       };
91410     } catch (...) {
91411       {
91412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91413       };
91414     }
91415   }
91416
91417   jresult = (void *)result;
91418   return jresult;
91419 }
91420
91421
91422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91423   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91424
91425   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91426   {
91427     try {
91428       delete arg1;
91429     } catch (std::out_of_range& e) {
91430       {
91431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91432       };
91433     } catch (std::exception& e) {
91434       {
91435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91436       };
91437     } catch (Dali::DaliException e) {
91438       {
91439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91440       };
91441     } catch (...) {
91442       {
91443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91444       };
91445     }
91446   }
91447
91448 }
91449
91450
91451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91452   void * jresult ;
91453   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91454   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91455
91456   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91457   if (!arg1) {
91458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91459     return 0;
91460   }
91461   {
91462     try {
91463       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91464     } catch (std::out_of_range& e) {
91465       {
91466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91467       };
91468     } catch (std::exception& e) {
91469       {
91470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91471       };
91472     } catch (Dali::DaliException e) {
91473       {
91474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91475       };
91476     } catch (...) {
91477       {
91478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91479       };
91480     }
91481   }
91482
91483   jresult = (void *)result;
91484   return jresult;
91485 }
91486
91487
91488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91489   void * jresult ;
91490   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91491   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91492   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91493
91494   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91495   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91496   if (!arg2) {
91497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91498     return 0;
91499   }
91500   {
91501     try {
91502       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91503     } catch (std::out_of_range& e) {
91504       {
91505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91506       };
91507     } catch (std::exception& e) {
91508       {
91509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91510       };
91511     } catch (Dali::DaliException e) {
91512       {
91513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91514       };
91515     } catch (...) {
91516       {
91517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91518       };
91519     }
91520   }
91521
91522   jresult = (void *)result;
91523   return jresult;
91524 }
91525
91526
91527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91528   void * jresult ;
91529   Dali::Toolkit::AsyncImageLoader result;
91530
91531   {
91532     try {
91533       result = Dali::Toolkit::AsyncImageLoader::New();
91534     } catch (std::out_of_range& e) {
91535       {
91536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91537       };
91538     } catch (std::exception& e) {
91539       {
91540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91541       };
91542     } catch (Dali::DaliException e) {
91543       {
91544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91545       };
91546     } catch (...) {
91547       {
91548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91549       };
91550     }
91551   }
91552
91553   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91554   return jresult;
91555 }
91556
91557
91558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91559   void * jresult ;
91560   Dali::BaseHandle arg1 ;
91561   Dali::BaseHandle *argp1 ;
91562   Dali::Toolkit::AsyncImageLoader result;
91563
91564   argp1 = (Dali::BaseHandle *)jarg1;
91565   if (!argp1) {
91566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91567     return 0;
91568   }
91569   arg1 = *argp1;
91570   {
91571     try {
91572       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91573     } catch (std::out_of_range& e) {
91574       {
91575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91576       };
91577     } catch (std::exception& e) {
91578       {
91579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91580       };
91581     } catch (Dali::DaliException e) {
91582       {
91583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91584       };
91585     } catch (...) {
91586       {
91587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91588       };
91589     }
91590   }
91591
91592   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91593   return jresult;
91594 }
91595
91596
91597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91598   unsigned int jresult ;
91599   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91600   std::string *arg2 = 0 ;
91601   uint32_t result;
91602
91603   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91604   if (!jarg2) {
91605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91606     return 0;
91607   }
91608   std::string arg2_str(jarg2);
91609   arg2 = &arg2_str;
91610   {
91611     try {
91612       result = (arg1)->Load((std::string const &)*arg2);
91613     } catch (std::out_of_range& e) {
91614       {
91615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91616       };
91617     } catch (std::exception& e) {
91618       {
91619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91620       };
91621     } catch (Dali::DaliException e) {
91622       {
91623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91624       };
91625     } catch (...) {
91626       {
91627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91628       };
91629     }
91630   }
91631
91632   jresult = result;
91633
91634   //argout typemap for const std::string&
91635
91636   return jresult;
91637 }
91638
91639
91640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91641   unsigned int jresult ;
91642   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91643   std::string *arg2 = 0 ;
91644   Dali::ImageDimensions arg3 ;
91645   Dali::ImageDimensions *argp3 ;
91646   uint32_t result;
91647
91648   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91649   if (!jarg2) {
91650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91651     return 0;
91652   }
91653   std::string arg2_str(jarg2);
91654   arg2 = &arg2_str;
91655   argp3 = (Dali::ImageDimensions *)jarg3;
91656   if (!argp3) {
91657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91658     return 0;
91659   }
91660   arg3 = *argp3;
91661   {
91662     try {
91663       result = (arg1)->Load((std::string const &)*arg2,arg3);
91664     } catch (std::out_of_range& e) {
91665       {
91666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91667       };
91668     } catch (std::exception& e) {
91669       {
91670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91671       };
91672     } catch (Dali::DaliException e) {
91673       {
91674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91675       };
91676     } catch (...) {
91677       {
91678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91679       };
91680     }
91681   }
91682
91683   jresult = result;
91684
91685   //argout typemap for const std::string&
91686
91687   return jresult;
91688 }
91689
91690
91691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
91692   unsigned int jresult ;
91693   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91694   std::string *arg2 = 0 ;
91695   Dali::ImageDimensions arg3 ;
91696   Dali::FittingMode::Type arg4 ;
91697   Dali::SamplingMode::Type arg5 ;
91698   bool arg6 ;
91699   Dali::ImageDimensions *argp3 ;
91700   uint32_t result;
91701
91702   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91703   if (!jarg2) {
91704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91705     return 0;
91706   }
91707   std::string arg2_str(jarg2);
91708   arg2 = &arg2_str;
91709   argp3 = (Dali::ImageDimensions *)jarg3;
91710   if (!argp3) {
91711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91712     return 0;
91713   }
91714   arg3 = *argp3;
91715   arg4 = (Dali::FittingMode::Type)jarg4;
91716   arg5 = (Dali::SamplingMode::Type)jarg5;
91717   arg6 = jarg6 ? true : false;
91718   {
91719     try {
91720       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
91721     } catch (std::out_of_range& e) {
91722       {
91723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91724       };
91725     } catch (std::exception& e) {
91726       {
91727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91728       };
91729     } catch (Dali::DaliException e) {
91730       {
91731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91732       };
91733     } catch (...) {
91734       {
91735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91736       };
91737     }
91738   }
91739
91740   jresult = result;
91741
91742   //argout typemap for const std::string&
91743
91744   return jresult;
91745 }
91746
91747
91748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91749   unsigned int jresult ;
91750   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91751   uint32_t arg2 ;
91752   bool result;
91753
91754   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91755   arg2 = (uint32_t)jarg2;
91756   {
91757     try {
91758       result = (bool)(arg1)->Cancel(arg2);
91759     } catch (std::out_of_range& e) {
91760       {
91761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91762       };
91763     } catch (std::exception& e) {
91764       {
91765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91766       };
91767     } catch (Dali::DaliException e) {
91768       {
91769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91770       };
91771     } catch (...) {
91772       {
91773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91774       };
91775     }
91776   }
91777
91778   jresult = result;
91779   return jresult;
91780 }
91781
91782
91783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91784   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91785
91786   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91787   {
91788     try {
91789       (arg1)->CancelAll();
91790     } catch (std::out_of_range& e) {
91791       {
91792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91793       };
91794     } catch (std::exception& e) {
91795       {
91796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91797       };
91798     } catch (Dali::DaliException e) {
91799       {
91800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91801       };
91802     } catch (...) {
91803       {
91804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91805       };
91806     }
91807   }
91808
91809 }
91810
91811
91812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
91813   void * jresult ;
91814   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91815   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
91816
91817   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91818   {
91819     try {
91820       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
91821     } catch (std::out_of_range& e) {
91822       {
91823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91824       };
91825     } catch (std::exception& e) {
91826       {
91827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91828       };
91829     } catch (Dali::DaliException e) {
91830       {
91831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91832       };
91833     } catch (...) {
91834       {
91835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91836       };
91837     }
91838   }
91839
91840   jresult = (void *)result;
91841   return jresult;
91842 }
91843
91844
91845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
91846   void * jresult ;
91847   std::string *arg1 = 0 ;
91848   Dali::PixelData result;
91849
91850   if (!jarg1) {
91851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91852     return 0;
91853   }
91854   std::string arg1_str(jarg1);
91855   arg1 = &arg1_str;
91856   {
91857     try {
91858       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
91859     } catch (std::out_of_range& e) {
91860       {
91861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91862       };
91863     } catch (std::exception& e) {
91864       {
91865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91866       };
91867     } catch (Dali::DaliException e) {
91868       {
91869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91870       };
91871     } catch (...) {
91872       {
91873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91874       };
91875     }
91876   }
91877
91878   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91879
91880   //argout typemap for const std::string&
91881
91882   return jresult;
91883 }
91884
91885
91886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
91887   void * jresult ;
91888   std::string *arg1 = 0 ;
91889   Dali::ImageDimensions arg2 ;
91890   Dali::ImageDimensions *argp2 ;
91891   Dali::PixelData result;
91892
91893   if (!jarg1) {
91894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91895     return 0;
91896   }
91897   std::string arg1_str(jarg1);
91898   arg1 = &arg1_str;
91899   argp2 = (Dali::ImageDimensions *)jarg2;
91900   if (!argp2) {
91901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91902     return 0;
91903   }
91904   arg2 = *argp2;
91905   {
91906     try {
91907       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
91908     } catch (std::out_of_range& e) {
91909       {
91910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91911       };
91912     } catch (std::exception& e) {
91913       {
91914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91915       };
91916     } catch (Dali::DaliException e) {
91917       {
91918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91919       };
91920     } catch (...) {
91921       {
91922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91923       };
91924     }
91925   }
91926
91927   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91928
91929   //argout typemap for const std::string&
91930
91931   return jresult;
91932 }
91933
91934
91935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91936   void * jresult ;
91937   std::string *arg1 = 0 ;
91938   Dali::ImageDimensions arg2 ;
91939   Dali::FittingMode::Type arg3 ;
91940   Dali::SamplingMode::Type arg4 ;
91941   bool arg5 ;
91942   Dali::ImageDimensions *argp2 ;
91943   Dali::PixelData result;
91944
91945   if (!jarg1) {
91946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91947     return 0;
91948   }
91949   std::string arg1_str(jarg1);
91950   arg1 = &arg1_str;
91951   argp2 = (Dali::ImageDimensions *)jarg2;
91952   if (!argp2) {
91953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91954     return 0;
91955   }
91956   arg2 = *argp2;
91957   arg3 = (Dali::FittingMode::Type)jarg3;
91958   arg4 = (Dali::SamplingMode::Type)jarg4;
91959   arg5 = jarg5 ? true : false;
91960   {
91961     try {
91962       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91963     } catch (std::out_of_range& e) {
91964       {
91965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91966       };
91967     } catch (std::exception& e) {
91968       {
91969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91970       };
91971     } catch (Dali::DaliException e) {
91972       {
91973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91974       };
91975     } catch (...) {
91976       {
91977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91978       };
91979     }
91980   }
91981
91982   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91983
91984   //argout typemap for const std::string&
91985
91986   return jresult;
91987 }
91988
91989
91990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91991   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91992
91993   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91994   {
91995     try {
91996       delete arg1;
91997     } catch (std::out_of_range& e) {
91998       {
91999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92000       };
92001     } catch (std::exception& e) {
92002       {
92003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92004       };
92005     } catch (Dali::DaliException e) {
92006       {
92007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92008       };
92009     } catch (...) {
92010       {
92011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92012       };
92013     }
92014   }
92015
92016 }
92017
92018
92019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92020   void * jresult ;
92021   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92022   Dali::Actor arg2 ;
92023   Dali::Actor arg3 ;
92024   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92025   Dali::Actor *argp2 ;
92026   Dali::Actor *argp3 ;
92027   Dali::Actor result;
92028
92029   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92030   argp2 = (Dali::Actor *)jarg2;
92031   if (!argp2) {
92032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92033     return 0;
92034   }
92035   arg2 = *argp2;
92036   argp3 = (Dali::Actor *)jarg3;
92037   if (!argp3) {
92038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92039     return 0;
92040   }
92041   arg3 = *argp3;
92042   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92043   {
92044     try {
92045       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92046     } catch (std::out_of_range& e) {
92047       {
92048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92049       };
92050     } catch (std::exception& e) {
92051       {
92052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92053       };
92054     } catch (Dali::DaliException e) {
92055       {
92056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92057       };
92058     } catch (...) {
92059       {
92060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92061       };
92062     }
92063   }
92064
92065   jresult = new Dali::Actor((const Dali::Actor &)result);
92066   return jresult;
92067 }
92068
92069
92070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92071   void * jresult ;
92072   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92073
92074   {
92075     try {
92076       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92077     } catch (std::out_of_range& e) {
92078       {
92079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92080       };
92081     } catch (std::exception& e) {
92082       {
92083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92084       };
92085     } catch (Dali::DaliException e) {
92086       {
92087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92088       };
92089     } catch (...) {
92090       {
92091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92092       };
92093     }
92094   }
92095
92096   jresult = (void *)result;
92097   return jresult;
92098 }
92099
92100
92101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92102   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92103   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92104   if (director) {
92105     director->swig_connect_director(callback0);
92106   }
92107 }
92108
92109
92110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92111   KeyboardFocusManager arg1 ;
92112   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92113   KeyboardFocusManager *argp1 ;
92114
92115   argp1 = (KeyboardFocusManager *)jarg1;
92116   if (!argp1) {
92117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92118     return ;
92119   }
92120   arg1 = *argp1;
92121   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92122   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
92123   {
92124     try {
92125       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92126     } catch (std::out_of_range& e) {
92127       {
92128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92129       };
92130     } catch (std::exception& e) {
92131       {
92132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92133       };
92134     } catch (Dali::DaliException e) {
92135       {
92136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92137       };
92138     } catch (...) {
92139       {
92140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92141       };
92142     }
92143   }
92144
92145 }
92146
92147
92148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92149   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92150
92151   arg1 = (std::vector< unsigned int > *)jarg1;
92152   {
92153     try {
92154       (arg1)->clear();
92155     } catch (std::out_of_range& e) {
92156       {
92157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92158       };
92159     } catch (std::exception& e) {
92160       {
92161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92162       };
92163     } catch (Dali::DaliException e) {
92164       {
92165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92166       };
92167     } catch (...) {
92168       {
92169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92170       };
92171     }
92172   }
92173
92174 }
92175
92176
92177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92178   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92179   unsigned int *arg2 = 0 ;
92180   unsigned int temp2 ;
92181
92182   arg1 = (std::vector< unsigned int > *)jarg1;
92183   temp2 = (unsigned int)jarg2;
92184   arg2 = &temp2;
92185   {
92186     try {
92187       (arg1)->push_back((unsigned int const &)*arg2);
92188     } catch (std::out_of_range& e) {
92189       {
92190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92191       };
92192     } catch (std::exception& e) {
92193       {
92194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92195       };
92196     } catch (Dali::DaliException e) {
92197       {
92198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92199       };
92200     } catch (...) {
92201       {
92202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92203       };
92204     }
92205   }
92206
92207 }
92208
92209
92210 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92211   unsigned long jresult ;
92212   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92213   std::vector< unsigned int >::size_type result;
92214
92215   arg1 = (std::vector< unsigned int > *)jarg1;
92216   {
92217     try {
92218       result = ((std::vector< unsigned int > const *)arg1)->size();
92219     } catch (std::out_of_range& e) {
92220       {
92221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92222       };
92223     } catch (std::exception& e) {
92224       {
92225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92226       };
92227     } catch (Dali::DaliException e) {
92228       {
92229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92230       };
92231     } catch (...) {
92232       {
92233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92234       };
92235     }
92236   }
92237
92238   jresult = (unsigned long)result;
92239   return jresult;
92240 }
92241
92242
92243 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92244   unsigned long jresult ;
92245   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92246   std::vector< unsigned int >::size_type result;
92247
92248   arg1 = (std::vector< unsigned int > *)jarg1;
92249   {
92250     try {
92251       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92252     } catch (std::out_of_range& e) {
92253       {
92254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92255       };
92256     } catch (std::exception& e) {
92257       {
92258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92259       };
92260     } catch (Dali::DaliException e) {
92261       {
92262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92263       };
92264     } catch (...) {
92265       {
92266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92267       };
92268     }
92269   }
92270
92271   jresult = (unsigned long)result;
92272   return jresult;
92273 }
92274
92275
92276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92277   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92278   std::vector< unsigned int >::size_type arg2 ;
92279
92280   arg1 = (std::vector< unsigned int > *)jarg1;
92281   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92282   {
92283     try {
92284       (arg1)->reserve(arg2);
92285     } catch (std::out_of_range& e) {
92286       {
92287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92288       };
92289     } catch (std::exception& e) {
92290       {
92291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92292       };
92293     } catch (Dali::DaliException e) {
92294       {
92295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92296       };
92297     } catch (...) {
92298       {
92299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92300       };
92301     }
92302   }
92303
92304 }
92305
92306
92307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92308   void * jresult ;
92309   std::vector< unsigned int > *result = 0 ;
92310
92311   {
92312     try {
92313       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92314     } catch (std::out_of_range& e) {
92315       {
92316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92317       };
92318     } catch (std::exception& e) {
92319       {
92320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92321       };
92322     } catch (Dali::DaliException e) {
92323       {
92324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92325       };
92326     } catch (...) {
92327       {
92328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92329       };
92330     }
92331   }
92332
92333   jresult = (void *)result;
92334   return jresult;
92335 }
92336
92337
92338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92339   void * jresult ;
92340   std::vector< unsigned int > *arg1 = 0 ;
92341   std::vector< unsigned int > *result = 0 ;
92342
92343   arg1 = (std::vector< unsigned int > *)jarg1;
92344   if (!arg1) {
92345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92346     return 0;
92347   }
92348   {
92349     try {
92350       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92351     } catch (std::out_of_range& e) {
92352       {
92353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92354       };
92355     } catch (std::exception& e) {
92356       {
92357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92358       };
92359     } catch (Dali::DaliException e) {
92360       {
92361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92362       };
92363     } catch (...) {
92364       {
92365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92366       };
92367     }
92368   }
92369
92370   jresult = (void *)result;
92371   return jresult;
92372 }
92373
92374
92375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92376   void * jresult ;
92377   int arg1 ;
92378   std::vector< unsigned int > *result = 0 ;
92379
92380   arg1 = (int)jarg1;
92381   {
92382     try {
92383       try {
92384         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92385       }
92386       catch(std::out_of_range &_e) {
92387         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92388         return 0;
92389       }
92390
92391     } catch (std::out_of_range& e) {
92392       {
92393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92394       };
92395     } catch (std::exception& e) {
92396       {
92397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92398       };
92399     } catch (Dali::DaliException e) {
92400       {
92401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92402       };
92403     } catch (...) {
92404       {
92405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92406       };
92407     }
92408   }
92409
92410   jresult = (void *)result;
92411   return jresult;
92412 }
92413
92414
92415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92416   unsigned int jresult ;
92417   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92418   int arg2 ;
92419   unsigned int result;
92420
92421   arg1 = (std::vector< unsigned int > *)jarg1;
92422   arg2 = (int)jarg2;
92423   {
92424     try {
92425       try {
92426         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92427       }
92428       catch(std::out_of_range &_e) {
92429         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92430         return 0;
92431       }
92432
92433     } catch (std::out_of_range& e) {
92434       {
92435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92436       };
92437     } catch (std::exception& e) {
92438       {
92439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92440       };
92441     } catch (Dali::DaliException e) {
92442       {
92443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92444       };
92445     } catch (...) {
92446       {
92447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92448       };
92449     }
92450   }
92451
92452   jresult = result;
92453   return jresult;
92454 }
92455
92456
92457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92458   unsigned int jresult ;
92459   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92460   int arg2 ;
92461   unsigned int *result = 0 ;
92462
92463   arg1 = (std::vector< unsigned int > *)jarg1;
92464   arg2 = (int)jarg2;
92465   {
92466     try {
92467       try {
92468         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92469       }
92470       catch(std::out_of_range &_e) {
92471         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92472         return 0;
92473       }
92474
92475     } catch (std::out_of_range& e) {
92476       {
92477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92478       };
92479     } catch (std::exception& e) {
92480       {
92481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92482       };
92483     } catch (Dali::DaliException e) {
92484       {
92485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92486       };
92487     } catch (...) {
92488       {
92489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92490       };
92491     }
92492   }
92493
92494   jresult = *result;
92495   return jresult;
92496 }
92497
92498
92499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92500   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92501   int arg2 ;
92502   unsigned int *arg3 = 0 ;
92503   unsigned int temp3 ;
92504
92505   arg1 = (std::vector< unsigned int > *)jarg1;
92506   arg2 = (int)jarg2;
92507   temp3 = (unsigned int)jarg3;
92508   arg3 = &temp3;
92509   {
92510     try {
92511       try {
92512         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92513       }
92514       catch(std::out_of_range &_e) {
92515         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92516         return ;
92517       }
92518
92519     } catch (std::out_of_range& e) {
92520       {
92521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92522       };
92523     } catch (std::exception& e) {
92524       {
92525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92526       };
92527     } catch (Dali::DaliException e) {
92528       {
92529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92530       };
92531     } catch (...) {
92532       {
92533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92534       };
92535     }
92536   }
92537
92538 }
92539
92540
92541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92542   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92543   std::vector< unsigned int > *arg2 = 0 ;
92544
92545   arg1 = (std::vector< unsigned int > *)jarg1;
92546   arg2 = (std::vector< unsigned int > *)jarg2;
92547   if (!arg2) {
92548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92549     return ;
92550   }
92551   {
92552     try {
92553       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92554     } catch (std::out_of_range& e) {
92555       {
92556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92557       };
92558     } catch (std::exception& e) {
92559       {
92560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92561       };
92562     } catch (Dali::DaliException e) {
92563       {
92564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92565       };
92566     } catch (...) {
92567       {
92568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92569       };
92570     }
92571   }
92572
92573 }
92574
92575
92576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92577   void * jresult ;
92578   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92579   int arg2 ;
92580   int arg3 ;
92581   std::vector< unsigned int > *result = 0 ;
92582
92583   arg1 = (std::vector< unsigned int > *)jarg1;
92584   arg2 = (int)jarg2;
92585   arg3 = (int)jarg3;
92586   {
92587     try {
92588       try {
92589         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92590       }
92591       catch(std::out_of_range &_e) {
92592         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92593         return 0;
92594       }
92595       catch(std::invalid_argument &_e) {
92596         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92597         return 0;
92598       }
92599
92600     } catch (std::out_of_range& e) {
92601       {
92602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92603       };
92604     } catch (std::exception& e) {
92605       {
92606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92607       };
92608     } catch (Dali::DaliException e) {
92609       {
92610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92611       };
92612     } catch (...) {
92613       {
92614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92615       };
92616     }
92617   }
92618
92619   jresult = (void *)result;
92620   return jresult;
92621 }
92622
92623
92624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92625   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92626   int arg2 ;
92627   unsigned int *arg3 = 0 ;
92628   unsigned int temp3 ;
92629
92630   arg1 = (std::vector< unsigned int > *)jarg1;
92631   arg2 = (int)jarg2;
92632   temp3 = (unsigned int)jarg3;
92633   arg3 = &temp3;
92634   {
92635     try {
92636       try {
92637         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92638       }
92639       catch(std::out_of_range &_e) {
92640         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92641         return ;
92642       }
92643
92644     } catch (std::out_of_range& e) {
92645       {
92646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92647       };
92648     } catch (std::exception& e) {
92649       {
92650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92651       };
92652     } catch (Dali::DaliException e) {
92653       {
92654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92655       };
92656     } catch (...) {
92657       {
92658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92659       };
92660     }
92661   }
92662
92663 }
92664
92665
92666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92667   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92668   int arg2 ;
92669   std::vector< unsigned int > *arg3 = 0 ;
92670
92671   arg1 = (std::vector< unsigned int > *)jarg1;
92672   arg2 = (int)jarg2;
92673   arg3 = (std::vector< unsigned int > *)jarg3;
92674   if (!arg3) {
92675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92676     return ;
92677   }
92678   {
92679     try {
92680       try {
92681         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92682       }
92683       catch(std::out_of_range &_e) {
92684         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92685         return ;
92686       }
92687
92688     } catch (std::out_of_range& e) {
92689       {
92690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92691       };
92692     } catch (std::exception& e) {
92693       {
92694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92695       };
92696     } catch (Dali::DaliException e) {
92697       {
92698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92699       };
92700     } catch (...) {
92701       {
92702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92703       };
92704     }
92705   }
92706
92707 }
92708
92709
92710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
92711   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92712   int arg2 ;
92713
92714   arg1 = (std::vector< unsigned int > *)jarg1;
92715   arg2 = (int)jarg2;
92716   {
92717     try {
92718       try {
92719         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
92720       }
92721       catch(std::out_of_range &_e) {
92722         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92723         return ;
92724       }
92725
92726     } catch (std::out_of_range& e) {
92727       {
92728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92729       };
92730     } catch (std::exception& e) {
92731       {
92732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92733       };
92734     } catch (Dali::DaliException e) {
92735       {
92736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92737       };
92738     } catch (...) {
92739       {
92740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92741       };
92742     }
92743   }
92744
92745 }
92746
92747
92748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92749   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92750   int arg2 ;
92751   int arg3 ;
92752
92753   arg1 = (std::vector< unsigned int > *)jarg1;
92754   arg2 = (int)jarg2;
92755   arg3 = (int)jarg3;
92756   {
92757     try {
92758       try {
92759         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
92760       }
92761       catch(std::out_of_range &_e) {
92762         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92763         return ;
92764       }
92765       catch(std::invalid_argument &_e) {
92766         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92767         return ;
92768       }
92769
92770     } catch (std::out_of_range& e) {
92771       {
92772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92773       };
92774     } catch (std::exception& e) {
92775       {
92776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92777       };
92778     } catch (Dali::DaliException e) {
92779       {
92780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92781       };
92782     } catch (...) {
92783       {
92784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92785       };
92786     }
92787   }
92788
92789 }
92790
92791
92792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
92793   void * jresult ;
92794   unsigned int *arg1 = 0 ;
92795   int arg2 ;
92796   unsigned int temp1 ;
92797   std::vector< unsigned int > *result = 0 ;
92798
92799   temp1 = (unsigned int)jarg1;
92800   arg1 = &temp1;
92801   arg2 = (int)jarg2;
92802   {
92803     try {
92804       try {
92805         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
92806       }
92807       catch(std::out_of_range &_e) {
92808         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92809         return 0;
92810       }
92811
92812     } catch (std::out_of_range& e) {
92813       {
92814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92815       };
92816     } catch (std::exception& e) {
92817       {
92818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92819       };
92820     } catch (Dali::DaliException e) {
92821       {
92822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92823       };
92824     } catch (...) {
92825       {
92826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92827       };
92828     }
92829   }
92830
92831   jresult = (void *)result;
92832   return jresult;
92833 }
92834
92835
92836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
92837   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92838
92839   arg1 = (std::vector< unsigned int > *)jarg1;
92840   {
92841     try {
92842       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
92843     } catch (std::out_of_range& e) {
92844       {
92845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92846       };
92847     } catch (std::exception& e) {
92848       {
92849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92850       };
92851     } catch (Dali::DaliException e) {
92852       {
92853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92854       };
92855     } catch (...) {
92856       {
92857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92858       };
92859     }
92860   }
92861
92862 }
92863
92864
92865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92866   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92867   int arg2 ;
92868   int arg3 ;
92869
92870   arg1 = (std::vector< unsigned int > *)jarg1;
92871   arg2 = (int)jarg2;
92872   arg3 = (int)jarg3;
92873   {
92874     try {
92875       try {
92876         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92877       }
92878       catch(std::out_of_range &_e) {
92879         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92880         return ;
92881       }
92882       catch(std::invalid_argument &_e) {
92883         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92884         return ;
92885       }
92886
92887     } catch (std::out_of_range& e) {
92888       {
92889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92890       };
92891     } catch (std::exception& e) {
92892       {
92893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92894       };
92895     } catch (Dali::DaliException e) {
92896       {
92897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92898       };
92899     } catch (...) {
92900       {
92901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92902       };
92903     }
92904   }
92905
92906 }
92907
92908
92909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92910   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92911   int arg2 ;
92912   std::vector< unsigned int > *arg3 = 0 ;
92913
92914   arg1 = (std::vector< unsigned int > *)jarg1;
92915   arg2 = (int)jarg2;
92916   arg3 = (std::vector< unsigned int > *)jarg3;
92917   if (!arg3) {
92918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92919     return ;
92920   }
92921   {
92922     try {
92923       try {
92924         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92925       }
92926       catch(std::out_of_range &_e) {
92927         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92928         return ;
92929       }
92930
92931     } catch (std::out_of_range& e) {
92932       {
92933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92934       };
92935     } catch (std::exception& e) {
92936       {
92937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92938       };
92939     } catch (Dali::DaliException e) {
92940       {
92941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92942       };
92943     } catch (...) {
92944       {
92945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92946       };
92947     }
92948   }
92949
92950 }
92951
92952
92953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92954   unsigned int jresult ;
92955   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92956   unsigned int *arg2 = 0 ;
92957   unsigned int temp2 ;
92958   bool result;
92959
92960   arg1 = (std::vector< unsigned int > *)jarg1;
92961   temp2 = (unsigned int)jarg2;
92962   arg2 = &temp2;
92963   {
92964     try {
92965       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92966     } catch (std::out_of_range& e) {
92967       {
92968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92969       };
92970     } catch (std::exception& e) {
92971       {
92972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92973       };
92974     } catch (Dali::DaliException e) {
92975       {
92976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92977       };
92978     } catch (...) {
92979       {
92980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92981       };
92982     }
92983   }
92984
92985   jresult = result;
92986   return jresult;
92987 }
92988
92989
92990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92991   int jresult ;
92992   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92993   unsigned int *arg2 = 0 ;
92994   unsigned int temp2 ;
92995   int result;
92996
92997   arg1 = (std::vector< unsigned int > *)jarg1;
92998   temp2 = (unsigned int)jarg2;
92999   arg2 = &temp2;
93000   {
93001     try {
93002       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93003     } catch (std::out_of_range& e) {
93004       {
93005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93006       };
93007     } catch (std::exception& e) {
93008       {
93009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93010       };
93011     } catch (Dali::DaliException e) {
93012       {
93013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93014       };
93015     } catch (...) {
93016       {
93017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93018       };
93019     }
93020   }
93021
93022   jresult = result;
93023   return jresult;
93024 }
93025
93026
93027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93028   int jresult ;
93029   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93030   unsigned int *arg2 = 0 ;
93031   unsigned int temp2 ;
93032   int result;
93033
93034   arg1 = (std::vector< unsigned int > *)jarg1;
93035   temp2 = (unsigned int)jarg2;
93036   arg2 = &temp2;
93037   {
93038     try {
93039       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93040     } catch (std::out_of_range& e) {
93041       {
93042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93043       };
93044     } catch (std::exception& e) {
93045       {
93046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93047       };
93048     } catch (Dali::DaliException e) {
93049       {
93050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93051       };
93052     } catch (...) {
93053       {
93054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93055       };
93056     }
93057   }
93058
93059   jresult = result;
93060   return jresult;
93061 }
93062
93063
93064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93065   unsigned int jresult ;
93066   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93067   unsigned int *arg2 = 0 ;
93068   unsigned int temp2 ;
93069   bool result;
93070
93071   arg1 = (std::vector< unsigned int > *)jarg1;
93072   temp2 = (unsigned int)jarg2;
93073   arg2 = &temp2;
93074   {
93075     try {
93076       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93077     } catch (std::out_of_range& e) {
93078       {
93079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93080       };
93081     } catch (std::exception& e) {
93082       {
93083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93084       };
93085     } catch (Dali::DaliException e) {
93086       {
93087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93088       };
93089     } catch (...) {
93090       {
93091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93092       };
93093     }
93094   }
93095
93096   jresult = result;
93097   return jresult;
93098 }
93099
93100
93101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93102   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93103
93104   arg1 = (std::vector< unsigned int > *)jarg1;
93105   {
93106     try {
93107       delete arg1;
93108     } catch (std::out_of_range& e) {
93109       {
93110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93111       };
93112     } catch (std::exception& e) {
93113       {
93114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93115       };
93116     } catch (Dali::DaliException e) {
93117       {
93118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93119       };
93120     } catch (...) {
93121       {
93122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93123       };
93124     }
93125   }
93126
93127 }
93128
93129
93130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93131   void * jresult ;
93132   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93133
93134   {
93135     try {
93136       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93137     } catch (std::out_of_range& e) {
93138       {
93139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93140       };
93141     } catch (std::exception& e) {
93142       {
93143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93144       };
93145     } catch (Dali::DaliException e) {
93146       {
93147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93148       };
93149     } catch (...) {
93150       {
93151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93152       };
93153     }
93154   }
93155
93156   jresult = (void *)result;
93157   return jresult;
93158 }
93159
93160
93161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93162   void * jresult ;
93163   unsigned int arg1 ;
93164   Dali::Actor arg2 ;
93165   Dali::Actor *argp2 ;
93166   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93167
93168   arg1 = (unsigned int)jarg1;
93169   argp2 = (Dali::Actor *)jarg2;
93170   if (!argp2) {
93171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93172     return 0;
93173   }
93174   arg2 = *argp2;
93175   {
93176     try {
93177       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93178     } catch (std::out_of_range& e) {
93179       {
93180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93181       };
93182     } catch (std::exception& e) {
93183       {
93184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93185       };
93186     } catch (Dali::DaliException e) {
93187       {
93188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93189       };
93190     } catch (...) {
93191       {
93192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93193       };
93194     }
93195   }
93196
93197   jresult = (void *)result;
93198   return jresult;
93199 }
93200
93201
93202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93203   void * jresult ;
93204   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93205   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93206
93207   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93208   if (!arg1) {
93209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93210     return 0;
93211   }
93212   {
93213     try {
93214       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93215     } catch (std::out_of_range& e) {
93216       {
93217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93218       };
93219     } catch (std::exception& e) {
93220       {
93221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93222       };
93223     } catch (Dali::DaliException e) {
93224       {
93225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93226       };
93227     } catch (...) {
93228       {
93229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93230       };
93231     }
93232   }
93233
93234   jresult = (void *)result;
93235   return jresult;
93236 }
93237
93238
93239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93240   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93241   unsigned int arg2 ;
93242
93243   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93244   arg2 = (unsigned int)jarg2;
93245   if (arg1) (arg1)->first = arg2;
93246 }
93247
93248
93249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93250   unsigned int jresult ;
93251   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93252   unsigned int result;
93253
93254   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93255   result = (unsigned int) ((arg1)->first);
93256   jresult = result;
93257   return jresult;
93258 }
93259
93260
93261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93262   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93263   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93264
93265   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93266   arg2 = (Dali::Actor *)jarg2;
93267   if (arg1) (arg1)->second = *arg2;
93268 }
93269
93270
93271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93272   void * jresult ;
93273   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93274   Dali::Actor *result = 0 ;
93275
93276   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93277   result = (Dali::Actor *)& ((arg1)->second);
93278   jresult = (void *)result;
93279   return jresult;
93280 }
93281
93282
93283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93284   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93285
93286   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93287   {
93288     try {
93289       delete arg1;
93290     } catch (std::out_of_range& e) {
93291       {
93292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93293       };
93294     } catch (std::exception& e) {
93295       {
93296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93297       };
93298     } catch (Dali::DaliException e) {
93299       {
93300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93301       };
93302     } catch (...) {
93303       {
93304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93305       };
93306     }
93307   }
93308
93309 }
93310
93311
93312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93313   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93314
93315   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93316   {
93317     try {
93318       (arg1)->clear();
93319     } catch (std::out_of_range& e) {
93320       {
93321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93322       };
93323     } catch (std::exception& e) {
93324       {
93325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93326       };
93327     } catch (Dali::DaliException e) {
93328       {
93329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93330       };
93331     } catch (...) {
93332       {
93333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93334       };
93335     }
93336   }
93337
93338 }
93339
93340
93341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93342   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93343   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93344
93345   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93346   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93347   if (!arg2) {
93348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93349     return ;
93350   }
93351   {
93352     try {
93353       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93354     } catch (std::out_of_range& e) {
93355       {
93356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93357       };
93358     } catch (std::exception& e) {
93359       {
93360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93361       };
93362     } catch (Dali::DaliException e) {
93363       {
93364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93365       };
93366     } catch (...) {
93367       {
93368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93369       };
93370     }
93371   }
93372
93373 }
93374
93375
93376 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93377   unsigned long jresult ;
93378   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93379   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93380
93381   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93382   {
93383     try {
93384       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93385     } catch (std::out_of_range& e) {
93386       {
93387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93388       };
93389     } catch (std::exception& e) {
93390       {
93391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93392       };
93393     } catch (Dali::DaliException e) {
93394       {
93395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93396       };
93397     } catch (...) {
93398       {
93399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93400       };
93401     }
93402   }
93403
93404   jresult = (unsigned long)result;
93405   return jresult;
93406 }
93407
93408
93409 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93410   unsigned long jresult ;
93411   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93412   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93413
93414   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93415   {
93416     try {
93417       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93418     } catch (std::out_of_range& e) {
93419       {
93420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93421       };
93422     } catch (std::exception& e) {
93423       {
93424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93425       };
93426     } catch (Dali::DaliException e) {
93427       {
93428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93429       };
93430     } catch (...) {
93431       {
93432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93433       };
93434     }
93435   }
93436
93437   jresult = (unsigned long)result;
93438   return jresult;
93439 }
93440
93441
93442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93443   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93444   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93445
93446   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93447   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93448   {
93449     try {
93450       (arg1)->reserve(arg2);
93451     } catch (std::out_of_range& e) {
93452       {
93453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93454       };
93455     } catch (std::exception& e) {
93456       {
93457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93458       };
93459     } catch (Dali::DaliException e) {
93460       {
93461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93462       };
93463     } catch (...) {
93464       {
93465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93466       };
93467     }
93468   }
93469
93470 }
93471
93472
93473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93474   void * jresult ;
93475   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93476
93477   {
93478     try {
93479       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93480     } catch (std::out_of_range& e) {
93481       {
93482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93483       };
93484     } catch (std::exception& e) {
93485       {
93486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93487       };
93488     } catch (Dali::DaliException e) {
93489       {
93490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93491       };
93492     } catch (...) {
93493       {
93494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93495       };
93496     }
93497   }
93498
93499   jresult = (void *)result;
93500   return jresult;
93501 }
93502
93503
93504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93505   void * jresult ;
93506   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93507   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93508
93509   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93510   if (!arg1) {
93511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93512     return 0;
93513   }
93514   {
93515     try {
93516       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);
93517     } catch (std::out_of_range& e) {
93518       {
93519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93520       };
93521     } catch (std::exception& e) {
93522       {
93523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93524       };
93525     } catch (Dali::DaliException e) {
93526       {
93527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93528       };
93529     } catch (...) {
93530       {
93531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93532       };
93533     }
93534   }
93535
93536   jresult = (void *)result;
93537   return jresult;
93538 }
93539
93540
93541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93542   void * jresult ;
93543   int arg1 ;
93544   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93545
93546   arg1 = (int)jarg1;
93547   {
93548     try {
93549       try {
93550         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);
93551       }
93552       catch(std::out_of_range &_e) {
93553         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93554         return 0;
93555       }
93556
93557     } catch (std::out_of_range& e) {
93558       {
93559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93560       };
93561     } catch (std::exception& e) {
93562       {
93563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93564       };
93565     } catch (Dali::DaliException e) {
93566       {
93567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93568       };
93569     } catch (...) {
93570       {
93571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93572       };
93573     }
93574   }
93575
93576   jresult = (void *)result;
93577   return jresult;
93578 }
93579
93580
93581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93582   void * jresult ;
93583   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93584   int arg2 ;
93585   std::pair< unsigned int,Dali::Actor > result;
93586
93587   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93588   arg2 = (int)jarg2;
93589   {
93590     try {
93591       try {
93592         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93593       }
93594       catch(std::out_of_range &_e) {
93595         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93596         return 0;
93597       }
93598
93599     } catch (std::out_of_range& e) {
93600       {
93601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93602       };
93603     } catch (std::exception& e) {
93604       {
93605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93606       };
93607     } catch (Dali::DaliException e) {
93608       {
93609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93610       };
93611     } catch (...) {
93612       {
93613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93614       };
93615     }
93616   }
93617
93618   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93619   return jresult;
93620 }
93621
93622
93623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93624   void * jresult ;
93625   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93626   int arg2 ;
93627   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93628
93629   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93630   arg2 = (int)jarg2;
93631   {
93632     try {
93633       try {
93634         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93635       }
93636       catch(std::out_of_range &_e) {
93637         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93638         return 0;
93639       }
93640
93641     } catch (std::out_of_range& e) {
93642       {
93643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93644       };
93645     } catch (std::exception& e) {
93646       {
93647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93648       };
93649     } catch (Dali::DaliException e) {
93650       {
93651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93652       };
93653     } catch (...) {
93654       {
93655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93656       };
93657     }
93658   }
93659
93660   jresult = (void *)result;
93661   return jresult;
93662 }
93663
93664
93665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93666   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93667   int arg2 ;
93668   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93669
93670   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93671   arg2 = (int)jarg2;
93672   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93673   if (!arg3) {
93674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93675     return ;
93676   }
93677   {
93678     try {
93679       try {
93680         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);
93681       }
93682       catch(std::out_of_range &_e) {
93683         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93684         return ;
93685       }
93686
93687     } catch (std::out_of_range& e) {
93688       {
93689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93690       };
93691     } catch (std::exception& e) {
93692       {
93693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93694       };
93695     } catch (Dali::DaliException e) {
93696       {
93697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93698       };
93699     } catch (...) {
93700       {
93701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93702       };
93703     }
93704   }
93705
93706 }
93707
93708
93709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
93710   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93711   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
93712
93713   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93714   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
93715   if (!arg2) {
93716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93717     return ;
93718   }
93719   {
93720     try {
93721       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);
93722     } catch (std::out_of_range& e) {
93723       {
93724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93725       };
93726     } catch (std::exception& e) {
93727       {
93728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93729       };
93730     } catch (Dali::DaliException e) {
93731       {
93732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93733       };
93734     } catch (...) {
93735       {
93736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93737       };
93738     }
93739   }
93740
93741 }
93742
93743
93744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93745   void * jresult ;
93746   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93747   int arg2 ;
93748   int arg3 ;
93749   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93750
93751   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93752   arg2 = (int)jarg2;
93753   arg3 = (int)jarg3;
93754   {
93755     try {
93756       try {
93757         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);
93758       }
93759       catch(std::out_of_range &_e) {
93760         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93761         return 0;
93762       }
93763       catch(std::invalid_argument &_e) {
93764         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93765         return 0;
93766       }
93767
93768     } catch (std::out_of_range& e) {
93769       {
93770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93771       };
93772     } catch (std::exception& e) {
93773       {
93774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93775       };
93776     } catch (Dali::DaliException e) {
93777       {
93778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93779       };
93780     } catch (...) {
93781       {
93782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93783       };
93784     }
93785   }
93786
93787   jresult = (void *)result;
93788   return jresult;
93789 }
93790
93791
93792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93793   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93794   int arg2 ;
93795   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93796
93797   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93798   arg2 = (int)jarg2;
93799   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93800   if (!arg3) {
93801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93802     return ;
93803   }
93804   {
93805     try {
93806       try {
93807         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);
93808       }
93809       catch(std::out_of_range &_e) {
93810         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93811         return ;
93812       }
93813
93814     } catch (std::out_of_range& e) {
93815       {
93816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93817       };
93818     } catch (std::exception& e) {
93819       {
93820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93821       };
93822     } catch (Dali::DaliException e) {
93823       {
93824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93825       };
93826     } catch (...) {
93827       {
93828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93829       };
93830     }
93831   }
93832
93833 }
93834
93835
93836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93837   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93838   int arg2 ;
93839   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93840
93841   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93842   arg2 = (int)jarg2;
93843   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93844   if (!arg3) {
93845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93846     return ;
93847   }
93848   {
93849     try {
93850       try {
93851         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);
93852       }
93853       catch(std::out_of_range &_e) {
93854         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93855         return ;
93856       }
93857
93858     } catch (std::out_of_range& e) {
93859       {
93860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93861       };
93862     } catch (std::exception& e) {
93863       {
93864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93865       };
93866     } catch (Dali::DaliException e) {
93867       {
93868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93869       };
93870     } catch (...) {
93871       {
93872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93873       };
93874     }
93875   }
93876
93877 }
93878
93879
93880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
93881   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93882   int arg2 ;
93883
93884   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93885   arg2 = (int)jarg2;
93886   {
93887     try {
93888       try {
93889         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
93890       }
93891       catch(std::out_of_range &_e) {
93892         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93893         return ;
93894       }
93895
93896     } catch (std::out_of_range& e) {
93897       {
93898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93899       };
93900     } catch (std::exception& e) {
93901       {
93902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93903       };
93904     } catch (Dali::DaliException e) {
93905       {
93906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93907       };
93908     } catch (...) {
93909       {
93910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93911       };
93912     }
93913   }
93914
93915 }
93916
93917
93918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93919   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93920   int arg2 ;
93921   int arg3 ;
93922
93923   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93924   arg2 = (int)jarg2;
93925   arg3 = (int)jarg3;
93926   {
93927     try {
93928       try {
93929         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
93930       }
93931       catch(std::out_of_range &_e) {
93932         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93933         return ;
93934       }
93935       catch(std::invalid_argument &_e) {
93936         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93937         return ;
93938       }
93939
93940     } catch (std::out_of_range& e) {
93941       {
93942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93943       };
93944     } catch (std::exception& e) {
93945       {
93946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93947       };
93948     } catch (Dali::DaliException e) {
93949       {
93950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93951       };
93952     } catch (...) {
93953       {
93954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93955       };
93956     }
93957   }
93958
93959 }
93960
93961
93962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93963   void * jresult ;
93964   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93965   int arg2 ;
93966   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93967
93968   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93969   if (!arg1) {
93970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93971     return 0;
93972   }
93973   arg2 = (int)jarg2;
93974   {
93975     try {
93976       try {
93977         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);
93978       }
93979       catch(std::out_of_range &_e) {
93980         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93981         return 0;
93982       }
93983
93984     } catch (std::out_of_range& e) {
93985       {
93986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93987       };
93988     } catch (std::exception& e) {
93989       {
93990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93991       };
93992     } catch (Dali::DaliException e) {
93993       {
93994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93995       };
93996     } catch (...) {
93997       {
93998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93999       };
94000     }
94001   }
94002
94003   jresult = (void *)result;
94004   return jresult;
94005 }
94006
94007
94008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94009   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94010
94011   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94012   {
94013     try {
94014       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94015     } catch (std::out_of_range& e) {
94016       {
94017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94018       };
94019     } catch (std::exception& e) {
94020       {
94021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94022       };
94023     } catch (Dali::DaliException e) {
94024       {
94025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94026       };
94027     } catch (...) {
94028       {
94029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94030       };
94031     }
94032   }
94033
94034 }
94035
94036
94037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94038   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94039   int arg2 ;
94040   int arg3 ;
94041
94042   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94043   arg2 = (int)jarg2;
94044   arg3 = (int)jarg3;
94045   {
94046     try {
94047       try {
94048         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94049       }
94050       catch(std::out_of_range &_e) {
94051         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94052         return ;
94053       }
94054       catch(std::invalid_argument &_e) {
94055         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94056         return ;
94057       }
94058
94059     } catch (std::out_of_range& e) {
94060       {
94061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94062       };
94063     } catch (std::exception& e) {
94064       {
94065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94066       };
94067     } catch (Dali::DaliException e) {
94068       {
94069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94070       };
94071     } catch (...) {
94072       {
94073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94074       };
94075     }
94076   }
94077
94078 }
94079
94080
94081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94082   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94083   int arg2 ;
94084   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94085
94086   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94087   arg2 = (int)jarg2;
94088   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94089   if (!arg3) {
94090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94091     return ;
94092   }
94093   {
94094     try {
94095       try {
94096         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);
94097       }
94098       catch(std::out_of_range &_e) {
94099         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94100         return ;
94101       }
94102
94103     } catch (std::out_of_range& e) {
94104       {
94105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94106       };
94107     } catch (std::exception& e) {
94108       {
94109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94110       };
94111     } catch (Dali::DaliException e) {
94112       {
94113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94114       };
94115     } catch (...) {
94116       {
94117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94118       };
94119     }
94120   }
94121
94122 }
94123
94124
94125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94126   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94127
94128   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94129   {
94130     try {
94131       delete arg1;
94132     } catch (std::out_of_range& e) {
94133       {
94134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94135       };
94136     } catch (std::exception& e) {
94137       {
94138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94139       };
94140     } catch (Dali::DaliException e) {
94141       {
94142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94143       };
94144     } catch (...) {
94145       {
94146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94147       };
94148     }
94149   }
94150
94151 }
94152
94153
94154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94155   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94156
94157   arg1 = (std::vector< Dali::Actor > *)jarg1;
94158   {
94159     try {
94160       (arg1)->clear();
94161     } catch (std::out_of_range& e) {
94162       {
94163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94164       };
94165     } catch (std::exception& e) {
94166       {
94167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94168       };
94169     } catch (Dali::DaliException e) {
94170       {
94171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94172       };
94173     } catch (...) {
94174       {
94175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94176       };
94177     }
94178   }
94179
94180 }
94181
94182
94183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94184   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94185   Dali::Actor *arg2 = 0 ;
94186
94187   arg1 = (std::vector< Dali::Actor > *)jarg1;
94188   arg2 = (Dali::Actor *)jarg2;
94189   if (!arg2) {
94190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94191     return ;
94192   }
94193   {
94194     try {
94195       (arg1)->push_back((Dali::Actor const &)*arg2);
94196     } catch (std::out_of_range& e) {
94197       {
94198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94199       };
94200     } catch (std::exception& e) {
94201       {
94202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94203       };
94204     } catch (Dali::DaliException e) {
94205       {
94206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94207       };
94208     } catch (...) {
94209       {
94210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94211       };
94212     }
94213   }
94214
94215 }
94216
94217
94218 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94219   unsigned long jresult ;
94220   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94221   std::vector< Dali::Actor >::size_type result;
94222
94223   arg1 = (std::vector< Dali::Actor > *)jarg1;
94224   {
94225     try {
94226       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94227     } catch (std::out_of_range& e) {
94228       {
94229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94230       };
94231     } catch (std::exception& e) {
94232       {
94233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94234       };
94235     } catch (Dali::DaliException e) {
94236       {
94237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94238       };
94239     } catch (...) {
94240       {
94241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94242       };
94243     }
94244   }
94245
94246   jresult = (unsigned long)result;
94247   return jresult;
94248 }
94249
94250
94251 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94252   unsigned long jresult ;
94253   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94254   std::vector< Dali::Actor >::size_type result;
94255
94256   arg1 = (std::vector< Dali::Actor > *)jarg1;
94257   {
94258     try {
94259       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94260     } catch (std::out_of_range& e) {
94261       {
94262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94263       };
94264     } catch (std::exception& e) {
94265       {
94266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94267       };
94268     } catch (Dali::DaliException e) {
94269       {
94270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94271       };
94272     } catch (...) {
94273       {
94274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94275       };
94276     }
94277   }
94278
94279   jresult = (unsigned long)result;
94280   return jresult;
94281 }
94282
94283
94284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94285   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94286   std::vector< Dali::Actor >::size_type arg2 ;
94287
94288   arg1 = (std::vector< Dali::Actor > *)jarg1;
94289   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94290   {
94291     try {
94292       (arg1)->reserve(arg2);
94293     } catch (std::out_of_range& e) {
94294       {
94295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94296       };
94297     } catch (std::exception& e) {
94298       {
94299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94300       };
94301     } catch (Dali::DaliException e) {
94302       {
94303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94304       };
94305     } catch (...) {
94306       {
94307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94308       };
94309     }
94310   }
94311
94312 }
94313
94314
94315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94316   void * jresult ;
94317   std::vector< Dali::Actor > *result = 0 ;
94318
94319   {
94320     try {
94321       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94322     } catch (std::out_of_range& e) {
94323       {
94324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94325       };
94326     } catch (std::exception& e) {
94327       {
94328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94329       };
94330     } catch (Dali::DaliException e) {
94331       {
94332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94333       };
94334     } catch (...) {
94335       {
94336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94337       };
94338     }
94339   }
94340
94341   jresult = (void *)result;
94342   return jresult;
94343 }
94344
94345
94346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94347   void * jresult ;
94348   std::vector< Dali::Actor > *arg1 = 0 ;
94349   std::vector< Dali::Actor > *result = 0 ;
94350
94351   arg1 = (std::vector< Dali::Actor > *)jarg1;
94352   if (!arg1) {
94353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94354     return 0;
94355   }
94356   {
94357     try {
94358       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94359     } catch (std::out_of_range& e) {
94360       {
94361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94362       };
94363     } catch (std::exception& e) {
94364       {
94365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94366       };
94367     } catch (Dali::DaliException e) {
94368       {
94369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94370       };
94371     } catch (...) {
94372       {
94373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94374       };
94375     }
94376   }
94377
94378   jresult = (void *)result;
94379   return jresult;
94380 }
94381
94382
94383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94384   void * jresult ;
94385   int arg1 ;
94386   std::vector< Dali::Actor > *result = 0 ;
94387
94388   arg1 = (int)jarg1;
94389   {
94390     try {
94391       try {
94392         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94393       }
94394       catch(std::out_of_range &_e) {
94395         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94396         return 0;
94397       }
94398
94399     } catch (std::out_of_range& e) {
94400       {
94401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94402       };
94403     } catch (std::exception& e) {
94404       {
94405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94406       };
94407     } catch (Dali::DaliException e) {
94408       {
94409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94410       };
94411     } catch (...) {
94412       {
94413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94414       };
94415     }
94416   }
94417
94418   jresult = (void *)result;
94419   return jresult;
94420 }
94421
94422
94423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94424   void * jresult ;
94425   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94426   int arg2 ;
94427   Dali::Actor result;
94428
94429   arg1 = (std::vector< Dali::Actor > *)jarg1;
94430   arg2 = (int)jarg2;
94431   {
94432     try {
94433       try {
94434         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94435       }
94436       catch(std::out_of_range &_e) {
94437         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94438         return 0;
94439       }
94440
94441     } catch (std::out_of_range& e) {
94442       {
94443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94444       };
94445     } catch (std::exception& e) {
94446       {
94447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94448       };
94449     } catch (Dali::DaliException e) {
94450       {
94451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94452       };
94453     } catch (...) {
94454       {
94455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94456       };
94457     }
94458   }
94459
94460   jresult = new Dali::Actor((const Dali::Actor &)result);
94461   return jresult;
94462 }
94463
94464
94465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94466   void * jresult ;
94467   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94468   int arg2 ;
94469   Dali::Actor *result = 0 ;
94470
94471   arg1 = (std::vector< Dali::Actor > *)jarg1;
94472   arg2 = (int)jarg2;
94473   {
94474     try {
94475       try {
94476         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94477       }
94478       catch(std::out_of_range &_e) {
94479         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94480         return 0;
94481       }
94482
94483     } catch (std::out_of_range& e) {
94484       {
94485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94486       };
94487     } catch (std::exception& e) {
94488       {
94489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94490       };
94491     } catch (Dali::DaliException e) {
94492       {
94493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94494       };
94495     } catch (...) {
94496       {
94497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94498       };
94499     }
94500   }
94501
94502   jresult = (void *)result;
94503   return jresult;
94504 }
94505
94506
94507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94508   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94509   int arg2 ;
94510   Dali::Actor *arg3 = 0 ;
94511
94512   arg1 = (std::vector< Dali::Actor > *)jarg1;
94513   arg2 = (int)jarg2;
94514   arg3 = (Dali::Actor *)jarg3;
94515   if (!arg3) {
94516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94517     return ;
94518   }
94519   {
94520     try {
94521       try {
94522         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94523       }
94524       catch(std::out_of_range &_e) {
94525         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94526         return ;
94527       }
94528
94529     } catch (std::out_of_range& e) {
94530       {
94531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94532       };
94533     } catch (std::exception& e) {
94534       {
94535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94536       };
94537     } catch (Dali::DaliException e) {
94538       {
94539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94540       };
94541     } catch (...) {
94542       {
94543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94544       };
94545     }
94546   }
94547
94548 }
94549
94550
94551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94552   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94553   std::vector< Dali::Actor > *arg2 = 0 ;
94554
94555   arg1 = (std::vector< Dali::Actor > *)jarg1;
94556   arg2 = (std::vector< Dali::Actor > *)jarg2;
94557   if (!arg2) {
94558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94559     return ;
94560   }
94561   {
94562     try {
94563       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94564     } catch (std::out_of_range& e) {
94565       {
94566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94567       };
94568     } catch (std::exception& e) {
94569       {
94570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94571       };
94572     } catch (Dali::DaliException e) {
94573       {
94574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94575       };
94576     } catch (...) {
94577       {
94578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94579       };
94580     }
94581   }
94582
94583 }
94584
94585
94586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94587   void * jresult ;
94588   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94589   int arg2 ;
94590   int arg3 ;
94591   std::vector< Dali::Actor > *result = 0 ;
94592
94593   arg1 = (std::vector< Dali::Actor > *)jarg1;
94594   arg2 = (int)jarg2;
94595   arg3 = (int)jarg3;
94596   {
94597     try {
94598       try {
94599         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94600       }
94601       catch(std::out_of_range &_e) {
94602         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94603         return 0;
94604       }
94605       catch(std::invalid_argument &_e) {
94606         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94607         return 0;
94608       }
94609
94610     } catch (std::out_of_range& e) {
94611       {
94612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94613       };
94614     } catch (std::exception& e) {
94615       {
94616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94617       };
94618     } catch (Dali::DaliException e) {
94619       {
94620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94621       };
94622     } catch (...) {
94623       {
94624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94625       };
94626     }
94627   }
94628
94629   jresult = (void *)result;
94630   return jresult;
94631 }
94632
94633
94634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94635   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94636   int arg2 ;
94637   Dali::Actor *arg3 = 0 ;
94638
94639   arg1 = (std::vector< Dali::Actor > *)jarg1;
94640   arg2 = (int)jarg2;
94641   arg3 = (Dali::Actor *)jarg3;
94642   if (!arg3) {
94643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94644     return ;
94645   }
94646   {
94647     try {
94648       try {
94649         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
94650       }
94651       catch(std::out_of_range &_e) {
94652         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94653         return ;
94654       }
94655
94656     } catch (std::out_of_range& e) {
94657       {
94658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94659       };
94660     } catch (std::exception& e) {
94661       {
94662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94663       };
94664     } catch (Dali::DaliException e) {
94665       {
94666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94667       };
94668     } catch (...) {
94669       {
94670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94671       };
94672     }
94673   }
94674
94675 }
94676
94677
94678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94679   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94680   int arg2 ;
94681   std::vector< Dali::Actor > *arg3 = 0 ;
94682
94683   arg1 = (std::vector< Dali::Actor > *)jarg1;
94684   arg2 = (int)jarg2;
94685   arg3 = (std::vector< Dali::Actor > *)jarg3;
94686   if (!arg3) {
94687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94688     return ;
94689   }
94690   {
94691     try {
94692       try {
94693         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94694       }
94695       catch(std::out_of_range &_e) {
94696         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94697         return ;
94698       }
94699
94700     } catch (std::out_of_range& e) {
94701       {
94702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94703       };
94704     } catch (std::exception& e) {
94705       {
94706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94707       };
94708     } catch (Dali::DaliException e) {
94709       {
94710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94711       };
94712     } catch (...) {
94713       {
94714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94715       };
94716     }
94717   }
94718
94719 }
94720
94721
94722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
94723   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94724   int arg2 ;
94725
94726   arg1 = (std::vector< Dali::Actor > *)jarg1;
94727   arg2 = (int)jarg2;
94728   {
94729     try {
94730       try {
94731         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
94732       }
94733       catch(std::out_of_range &_e) {
94734         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94735         return ;
94736       }
94737
94738     } catch (std::out_of_range& e) {
94739       {
94740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94741       };
94742     } catch (std::exception& e) {
94743       {
94744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94745       };
94746     } catch (Dali::DaliException e) {
94747       {
94748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94749       };
94750     } catch (...) {
94751       {
94752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94753       };
94754     }
94755   }
94756
94757 }
94758
94759
94760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94761   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94762   int arg2 ;
94763   int arg3 ;
94764
94765   arg1 = (std::vector< Dali::Actor > *)jarg1;
94766   arg2 = (int)jarg2;
94767   arg3 = (int)jarg3;
94768   {
94769     try {
94770       try {
94771         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
94772       }
94773       catch(std::out_of_range &_e) {
94774         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94775         return ;
94776       }
94777       catch(std::invalid_argument &_e) {
94778         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94779         return ;
94780       }
94781
94782     } catch (std::out_of_range& e) {
94783       {
94784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94785       };
94786     } catch (std::exception& e) {
94787       {
94788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94789       };
94790     } catch (Dali::DaliException e) {
94791       {
94792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94793       };
94794     } catch (...) {
94795       {
94796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94797       };
94798     }
94799   }
94800
94801 }
94802
94803
94804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
94805   void * jresult ;
94806   Dali::Actor *arg1 = 0 ;
94807   int arg2 ;
94808   std::vector< Dali::Actor > *result = 0 ;
94809
94810   arg1 = (Dali::Actor *)jarg1;
94811   if (!arg1) {
94812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94813     return 0;
94814   }
94815   arg2 = (int)jarg2;
94816   {
94817     try {
94818       try {
94819         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
94820       }
94821       catch(std::out_of_range &_e) {
94822         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94823         return 0;
94824       }
94825
94826     } catch (std::out_of_range& e) {
94827       {
94828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94829       };
94830     } catch (std::exception& e) {
94831       {
94832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94833       };
94834     } catch (Dali::DaliException e) {
94835       {
94836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94837       };
94838     } catch (...) {
94839       {
94840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94841       };
94842     }
94843   }
94844
94845   jresult = (void *)result;
94846   return jresult;
94847 }
94848
94849
94850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
94851   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94852
94853   arg1 = (std::vector< Dali::Actor > *)jarg1;
94854   {
94855     try {
94856       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
94857     } catch (std::out_of_range& e) {
94858       {
94859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94860       };
94861     } catch (std::exception& e) {
94862       {
94863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94864       };
94865     } catch (Dali::DaliException e) {
94866       {
94867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94868       };
94869     } catch (...) {
94870       {
94871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94872       };
94873     }
94874   }
94875
94876 }
94877
94878
94879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94880   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94881   int arg2 ;
94882   int arg3 ;
94883
94884   arg1 = (std::vector< Dali::Actor > *)jarg1;
94885   arg2 = (int)jarg2;
94886   arg3 = (int)jarg3;
94887   {
94888     try {
94889       try {
94890         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94891       }
94892       catch(std::out_of_range &_e) {
94893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94894         return ;
94895       }
94896       catch(std::invalid_argument &_e) {
94897         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94898         return ;
94899       }
94900
94901     } catch (std::out_of_range& e) {
94902       {
94903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94904       };
94905     } catch (std::exception& e) {
94906       {
94907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94908       };
94909     } catch (Dali::DaliException e) {
94910       {
94911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94912       };
94913     } catch (...) {
94914       {
94915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94916       };
94917     }
94918   }
94919
94920 }
94921
94922
94923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94924   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94925   int arg2 ;
94926   std::vector< Dali::Actor > *arg3 = 0 ;
94927
94928   arg1 = (std::vector< Dali::Actor > *)jarg1;
94929   arg2 = (int)jarg2;
94930   arg3 = (std::vector< Dali::Actor > *)jarg3;
94931   if (!arg3) {
94932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94933     return ;
94934   }
94935   {
94936     try {
94937       try {
94938         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94939       }
94940       catch(std::out_of_range &_e) {
94941         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94942         return ;
94943       }
94944
94945     } catch (std::out_of_range& e) {
94946       {
94947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94948       };
94949     } catch (std::exception& e) {
94950       {
94951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94952       };
94953     } catch (Dali::DaliException e) {
94954       {
94955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94956       };
94957     } catch (...) {
94958       {
94959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94960       };
94961     }
94962   }
94963
94964 }
94965
94966
94967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94968   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94969
94970   arg1 = (std::vector< Dali::Actor > *)jarg1;
94971   {
94972     try {
94973       delete arg1;
94974     } catch (std::out_of_range& e) {
94975       {
94976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94977       };
94978     } catch (std::exception& e) {
94979       {
94980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94981       };
94982     } catch (Dali::DaliException e) {
94983       {
94984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94985       };
94986     } catch (...) {
94987       {
94988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94989       };
94990     }
94991   }
94992
94993 }
94994
94995
94996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94997   unsigned int jresult ;
94998   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94999   bool result;
95000
95001   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95002   {
95003     try {
95004       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95005     } catch (std::out_of_range& e) {
95006       {
95007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95008       };
95009     } catch (std::exception& e) {
95010       {
95011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95012       };
95013     } catch (Dali::DaliException e) {
95014       {
95015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95016       };
95017     } catch (...) {
95018       {
95019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95020       };
95021     }
95022   }
95023
95024   jresult = result;
95025   return jresult;
95026 }
95027
95028
95029 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95030   unsigned long jresult ;
95031   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95032   std::size_t result;
95033
95034   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95035   {
95036     try {
95037       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95038     } catch (std::out_of_range& e) {
95039       {
95040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95041       };
95042     } catch (std::exception& e) {
95043       {
95044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95045       };
95046     } catch (Dali::DaliException e) {
95047       {
95048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95049       };
95050     } catch (...) {
95051       {
95052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95053       };
95054     }
95055   }
95056
95057   jresult = (unsigned long)result;
95058   return jresult;
95059 }
95060
95061
95062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95063   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95064   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95065
95066   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95067   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95068   {
95069     try {
95070       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95071     } catch (std::out_of_range& e) {
95072       {
95073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95074       };
95075     } catch (std::exception& e) {
95076       {
95077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95078       };
95079     } catch (Dali::DaliException e) {
95080       {
95081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95082       };
95083     } catch (...) {
95084       {
95085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95086       };
95087     }
95088   }
95089
95090 }
95091
95092
95093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95094   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95095   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95096
95097   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95098   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95099   {
95100     try {
95101       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95102     } catch (std::out_of_range& e) {
95103       {
95104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95105       };
95106     } catch (std::exception& e) {
95107       {
95108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95109       };
95110     } catch (Dali::DaliException e) {
95111       {
95112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95113       };
95114     } catch (...) {
95115       {
95116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95117       };
95118     }
95119   }
95120
95121 }
95122
95123
95124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95125   unsigned int jresult ;
95126   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95127   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95128   bool result;
95129
95130   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95131   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95132   if (!arg2) {
95133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95134     return 0;
95135   }
95136   {
95137     try {
95138       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95139     } catch (std::out_of_range& e) {
95140       {
95141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95142       };
95143     } catch (std::exception& e) {
95144       {
95145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95146       };
95147     } catch (Dali::DaliException e) {
95148       {
95149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95150       };
95151     } catch (...) {
95152       {
95153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95154       };
95155     }
95156   }
95157
95158   jresult = result;
95159   return jresult;
95160 }
95161
95162
95163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95164   void * jresult ;
95165   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95166
95167   {
95168     try {
95169       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95170     } catch (std::out_of_range& e) {
95171       {
95172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95173       };
95174     } catch (std::exception& e) {
95175       {
95176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95177       };
95178     } catch (Dali::DaliException e) {
95179       {
95180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95181       };
95182     } catch (...) {
95183       {
95184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95185       };
95186     }
95187   }
95188
95189   jresult = (void *)result;
95190   return jresult;
95191 }
95192
95193
95194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95195   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95196
95197   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95198   {
95199     try {
95200       delete arg1;
95201     } catch (std::out_of_range& e) {
95202       {
95203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95204       };
95205     } catch (std::exception& e) {
95206       {
95207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95208       };
95209     } catch (Dali::DaliException e) {
95210       {
95211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95212       };
95213     } catch (...) {
95214       {
95215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95216       };
95217     }
95218   }
95219
95220 }
95221
95222
95223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95224   unsigned int jresult ;
95225   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95226   bool result;
95227
95228   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95229   {
95230     try {
95231       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);
95232     } catch (std::out_of_range& e) {
95233       {
95234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95235       };
95236     } catch (std::exception& e) {
95237       {
95238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95239       };
95240     } catch (Dali::DaliException e) {
95241       {
95242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95243       };
95244     } catch (...) {
95245       {
95246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95247       };
95248     }
95249   }
95250
95251   jresult = result;
95252   return jresult;
95253 }
95254
95255
95256 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95257   unsigned long jresult ;
95258   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95259   std::size_t result;
95260
95261   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95262   {
95263     try {
95264       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);
95265     } catch (std::out_of_range& e) {
95266       {
95267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95268       };
95269     } catch (std::exception& e) {
95270       {
95271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95272       };
95273     } catch (Dali::DaliException e) {
95274       {
95275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95276       };
95277     } catch (...) {
95278       {
95279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95280       };
95281     }
95282   }
95283
95284   jresult = (unsigned long)result;
95285   return jresult;
95286 }
95287
95288
95289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95290   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95291   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95292
95293   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95294   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95295   {
95296     try {
95297       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95298     } catch (std::out_of_range& e) {
95299       {
95300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95301       };
95302     } catch (std::exception& e) {
95303       {
95304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95305       };
95306     } catch (Dali::DaliException e) {
95307       {
95308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95309       };
95310     } catch (...) {
95311       {
95312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95313       };
95314     }
95315   }
95316
95317 }
95318
95319
95320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95321   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95322   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95323
95324   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95325   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95326   {
95327     try {
95328       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95329     } catch (std::out_of_range& e) {
95330       {
95331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95332       };
95333     } catch (std::exception& e) {
95334       {
95335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95336       };
95337     } catch (Dali::DaliException e) {
95338       {
95339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95340       };
95341     } catch (...) {
95342       {
95343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95344       };
95345     }
95346   }
95347
95348 }
95349
95350
95351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95352   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95353   Dali::Actor arg2 ;
95354   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95355   Dali::Actor *argp2 ;
95356
95357   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95358   argp2 = (Dali::Actor *)jarg2;
95359   if (!argp2) {
95360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95361     return ;
95362   }
95363   arg2 = *argp2;
95364   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95365   {
95366     try {
95367       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95368     } catch (std::out_of_range& e) {
95369       {
95370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95371       };
95372     } catch (std::exception& e) {
95373       {
95374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95375       };
95376     } catch (Dali::DaliException e) {
95377       {
95378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95379       };
95380     } catch (...) {
95381       {
95382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95383       };
95384     }
95385   }
95386
95387 }
95388
95389
95390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95391   void * jresult ;
95392   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95393
95394   {
95395     try {
95396       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95397     } catch (std::out_of_range& e) {
95398       {
95399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95400       };
95401     } catch (std::exception& e) {
95402       {
95403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95404       };
95405     } catch (Dali::DaliException e) {
95406       {
95407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95408       };
95409     } catch (...) {
95410       {
95411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95412       };
95413     }
95414   }
95415
95416   jresult = (void *)result;
95417   return jresult;
95418 }
95419
95420
95421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95422   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95423
95424   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95425   {
95426     try {
95427       delete arg1;
95428     } catch (std::out_of_range& e) {
95429       {
95430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95431       };
95432     } catch (std::exception& e) {
95433       {
95434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95435       };
95436     } catch (Dali::DaliException e) {
95437       {
95438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95439       };
95440     } catch (...) {
95441       {
95442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95443       };
95444     }
95445   }
95446
95447 }
95448
95449
95450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95451   unsigned int jresult ;
95452   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95453   bool result;
95454
95455   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95456   {
95457     try {
95458       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95459     } catch (std::out_of_range& e) {
95460       {
95461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95462       };
95463     } catch (std::exception& e) {
95464       {
95465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95466       };
95467     } catch (Dali::DaliException e) {
95468       {
95469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95470       };
95471     } catch (...) {
95472       {
95473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95474       };
95475     }
95476   }
95477
95478   jresult = result;
95479   return jresult;
95480 }
95481
95482
95483 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95484   unsigned long jresult ;
95485   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95486   std::size_t result;
95487
95488   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95489   {
95490     try {
95491       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95492     } catch (std::out_of_range& e) {
95493       {
95494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95495       };
95496     } catch (std::exception& e) {
95497       {
95498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95499       };
95500     } catch (Dali::DaliException e) {
95501       {
95502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95503       };
95504     } catch (...) {
95505       {
95506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95507       };
95508     }
95509   }
95510
95511   jresult = (unsigned long)result;
95512   return jresult;
95513 }
95514
95515
95516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95517   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95518   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95519
95520   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95521   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95522   {
95523     try {
95524       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95525     } catch (std::out_of_range& e) {
95526       {
95527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95528       };
95529     } catch (std::exception& e) {
95530       {
95531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95532       };
95533     } catch (Dali::DaliException e) {
95534       {
95535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95536       };
95537     } catch (...) {
95538       {
95539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95540       };
95541     }
95542   }
95543
95544 }
95545
95546
95547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95548   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95549   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95550
95551   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95552   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95553   {
95554     try {
95555       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95556     } catch (std::out_of_range& e) {
95557       {
95558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95559       };
95560     } catch (std::exception& e) {
95561       {
95562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95563       };
95564     } catch (Dali::DaliException e) {
95565       {
95566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95567       };
95568     } catch (...) {
95569       {
95570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95571       };
95572     }
95573   }
95574
95575 }
95576
95577
95578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95579   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95580   Dali::Actor arg2 ;
95581   Dali::Actor arg3 ;
95582   Dali::Actor *argp2 ;
95583   Dali::Actor *argp3 ;
95584
95585   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95586   argp2 = (Dali::Actor *)jarg2;
95587   if (!argp2) {
95588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95589     return ;
95590   }
95591   arg2 = *argp2;
95592   argp3 = (Dali::Actor *)jarg3;
95593   if (!argp3) {
95594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95595     return ;
95596   }
95597   arg3 = *argp3;
95598   {
95599     try {
95600       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95601     } catch (std::out_of_range& e) {
95602       {
95603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95604       };
95605     } catch (std::exception& e) {
95606       {
95607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95608       };
95609     } catch (Dali::DaliException e) {
95610       {
95611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95612       };
95613     } catch (...) {
95614       {
95615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95616       };
95617     }
95618   }
95619
95620 }
95621
95622
95623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95624   void * jresult ;
95625   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95626
95627   {
95628     try {
95629       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95630     } catch (std::out_of_range& e) {
95631       {
95632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95633       };
95634     } catch (std::exception& e) {
95635       {
95636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95637       };
95638     } catch (Dali::DaliException e) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95641       };
95642     } catch (...) {
95643       {
95644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95645       };
95646     }
95647   }
95648
95649   jresult = (void *)result;
95650   return jresult;
95651 }
95652
95653
95654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
95655   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95656
95657   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95658   {
95659     try {
95660       delete arg1;
95661     } catch (std::out_of_range& e) {
95662       {
95663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95664       };
95665     } catch (std::exception& e) {
95666       {
95667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95668       };
95669     } catch (Dali::DaliException e) {
95670       {
95671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95672       };
95673     } catch (...) {
95674       {
95675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95676       };
95677     }
95678   }
95679
95680 }
95681
95682
95683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
95684   unsigned int jresult ;
95685   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95686   bool result;
95687
95688   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95689   {
95690     try {
95691       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95692     } catch (std::out_of_range& e) {
95693       {
95694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95695       };
95696     } catch (std::exception& e) {
95697       {
95698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95699       };
95700     } catch (Dali::DaliException e) {
95701       {
95702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95703       };
95704     } catch (...) {
95705       {
95706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95707       };
95708     }
95709   }
95710
95711   jresult = result;
95712   return jresult;
95713 }
95714
95715
95716 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
95717   unsigned long jresult ;
95718   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95719   std::size_t result;
95720
95721   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95722   {
95723     try {
95724       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95725     } catch (std::out_of_range& e) {
95726       {
95727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95728       };
95729     } catch (std::exception& e) {
95730       {
95731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95732       };
95733     } catch (Dali::DaliException e) {
95734       {
95735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95736       };
95737     } catch (...) {
95738       {
95739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95740       };
95741     }
95742   }
95743
95744   jresult = (unsigned long)result;
95745   return jresult;
95746 }
95747
95748
95749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
95750   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95751   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95752
95753   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95754   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95755   {
95756     try {
95757       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
95758     } catch (std::out_of_range& e) {
95759       {
95760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95761       };
95762     } catch (std::exception& e) {
95763       {
95764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95765       };
95766     } catch (Dali::DaliException e) {
95767       {
95768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95769       };
95770     } catch (...) {
95771       {
95772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95773       };
95774     }
95775   }
95776
95777 }
95778
95779
95780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95781   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95782   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95783
95784   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95785   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95786   {
95787     try {
95788       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95789     } catch (std::out_of_range& e) {
95790       {
95791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95792       };
95793     } catch (std::exception& e) {
95794       {
95795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95796       };
95797     } catch (Dali::DaliException e) {
95798       {
95799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95800       };
95801     } catch (...) {
95802       {
95803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95804       };
95805     }
95806   }
95807
95808 }
95809
95810
95811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
95812   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95813   Dali::Actor arg2 ;
95814   bool arg3 ;
95815   Dali::Actor *argp2 ;
95816
95817   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95818   argp2 = (Dali::Actor *)jarg2;
95819   if (!argp2) {
95820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95821     return ;
95822   }
95823   arg2 = *argp2;
95824   arg3 = jarg3 ? true : false;
95825   {
95826     try {
95827       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
95828     } catch (std::out_of_range& e) {
95829       {
95830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95831       };
95832     } catch (std::exception& e) {
95833       {
95834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95835       };
95836     } catch (Dali::DaliException e) {
95837       {
95838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95839       };
95840     } catch (...) {
95841       {
95842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95843       };
95844     }
95845   }
95846
95847 }
95848
95849
95850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
95851   void * jresult ;
95852   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
95853
95854   {
95855     try {
95856       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
95857     } catch (std::out_of_range& e) {
95858       {
95859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95860       };
95861     } catch (std::exception& e) {
95862       {
95863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95864       };
95865     } catch (Dali::DaliException e) {
95866       {
95867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95868       };
95869     } catch (...) {
95870       {
95871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95872       };
95873     }
95874   }
95875
95876   jresult = (void *)result;
95877   return jresult;
95878 }
95879
95880
95881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
95882   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95883
95884   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95885   {
95886     try {
95887       delete arg1;
95888     } catch (std::out_of_range& e) {
95889       {
95890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95891       };
95892     } catch (std::exception& e) {
95893       {
95894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95895       };
95896     } catch (Dali::DaliException e) {
95897       {
95898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95899       };
95900     } catch (...) {
95901       {
95902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95903       };
95904     }
95905   }
95906
95907 }
95908
95909
95910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
95911   unsigned int jresult ;
95912   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95913   bool result;
95914
95915   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95916   {
95917     try {
95918       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);
95919     } catch (std::out_of_range& e) {
95920       {
95921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95922       };
95923     } catch (std::exception& e) {
95924       {
95925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95926       };
95927     } catch (Dali::DaliException e) {
95928       {
95929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95930       };
95931     } catch (...) {
95932       {
95933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95934       };
95935     }
95936   }
95937
95938   jresult = result;
95939   return jresult;
95940 }
95941
95942
95943 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95944   unsigned long jresult ;
95945   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95946   std::size_t result;
95947
95948   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95949   {
95950     try {
95951       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);
95952     } catch (std::out_of_range& e) {
95953       {
95954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95955       };
95956     } catch (std::exception& e) {
95957       {
95958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95959       };
95960     } catch (Dali::DaliException e) {
95961       {
95962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95963       };
95964     } catch (...) {
95965       {
95966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95967       };
95968     }
95969   }
95970
95971   jresult = (unsigned long)result;
95972   return jresult;
95973 }
95974
95975
95976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95977   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95978   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95979
95980   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95981   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95982   {
95983     try {
95984       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95985     } catch (std::out_of_range& e) {
95986       {
95987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95988       };
95989     } catch (std::exception& e) {
95990       {
95991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95992       };
95993     } catch (Dali::DaliException e) {
95994       {
95995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95996       };
95997     } catch (...) {
95998       {
95999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96000       };
96001     }
96002   }
96003
96004 }
96005
96006
96007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96008   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96009   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96010
96011   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96012   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96013   {
96014     try {
96015       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96016     } catch (std::out_of_range& e) {
96017       {
96018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96019       };
96020     } catch (std::exception& e) {
96021       {
96022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96023       };
96024     } catch (Dali::DaliException e) {
96025       {
96026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96027       };
96028     } catch (...) {
96029       {
96030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96031       };
96032     }
96033   }
96034
96035 }
96036
96037
96038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96039   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96040   Dali::Toolkit::StyleManager arg2 ;
96041   Dali::StyleChange::Type arg3 ;
96042   Dali::Toolkit::StyleManager *argp2 ;
96043
96044   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96045   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96046   if (!argp2) {
96047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96048     return ;
96049   }
96050   arg2 = *argp2;
96051   arg3 = (Dali::StyleChange::Type)jarg3;
96052   {
96053     try {
96054       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96055     } catch (std::out_of_range& e) {
96056       {
96057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96058       };
96059     } catch (std::exception& e) {
96060       {
96061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96062       };
96063     } catch (Dali::DaliException e) {
96064       {
96065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96066       };
96067     } catch (...) {
96068       {
96069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96070       };
96071     }
96072   }
96073
96074 }
96075
96076
96077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96078   void * jresult ;
96079   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96080
96081   {
96082     try {
96083       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96084     } catch (std::out_of_range& e) {
96085       {
96086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96087       };
96088     } catch (std::exception& e) {
96089       {
96090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96091       };
96092     } catch (Dali::DaliException e) {
96093       {
96094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96095       };
96096     } catch (...) {
96097       {
96098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96099       };
96100     }
96101   }
96102
96103   jresult = (void *)result;
96104   return jresult;
96105 }
96106
96107
96108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96109   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96110
96111   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96112   {
96113     try {
96114       delete arg1;
96115     } catch (std::out_of_range& e) {
96116       {
96117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96118       };
96119     } catch (std::exception& e) {
96120       {
96121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96122       };
96123     } catch (Dali::DaliException e) {
96124       {
96125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96126       };
96127     } catch (...) {
96128       {
96129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96130       };
96131     }
96132   }
96133
96134 }
96135
96136
96137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96138   unsigned int jresult ;
96139   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96140   bool result;
96141
96142   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96143   {
96144     try {
96145       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96146     } catch (std::out_of_range& e) {
96147       {
96148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96149       };
96150     } catch (std::exception& e) {
96151       {
96152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96153       };
96154     } catch (Dali::DaliException e) {
96155       {
96156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96157       };
96158     } catch (...) {
96159       {
96160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96161       };
96162     }
96163   }
96164
96165   jresult = result;
96166   return jresult;
96167 }
96168
96169
96170 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96171   unsigned long jresult ;
96172   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96173   std::size_t result;
96174
96175   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96176   {
96177     try {
96178       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96179     } catch (std::out_of_range& e) {
96180       {
96181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96182       };
96183     } catch (std::exception& e) {
96184       {
96185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96186       };
96187     } catch (Dali::DaliException e) {
96188       {
96189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96190       };
96191     } catch (...) {
96192       {
96193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96194       };
96195     }
96196   }
96197
96198   jresult = (unsigned long)result;
96199   return jresult;
96200 }
96201
96202
96203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96204   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96205   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96206
96207   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96208   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96209   {
96210     try {
96211       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96212     } catch (std::out_of_range& e) {
96213       {
96214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96215       };
96216     } catch (std::exception& e) {
96217       {
96218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96219       };
96220     } catch (Dali::DaliException e) {
96221       {
96222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96223       };
96224     } catch (...) {
96225       {
96226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96227       };
96228     }
96229   }
96230
96231 }
96232
96233
96234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96235   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96236   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96237
96238   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96239   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96240   {
96241     try {
96242       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96243     } catch (std::out_of_range& e) {
96244       {
96245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96246       };
96247     } catch (std::exception& e) {
96248       {
96249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96250       };
96251     } catch (Dali::DaliException e) {
96252       {
96253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96254       };
96255     } catch (...) {
96256       {
96257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96258       };
96259     }
96260   }
96261
96262 }
96263
96264
96265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96266   unsigned int jresult ;
96267   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96268   Dali::Toolkit::Button arg2 ;
96269   Dali::Toolkit::Button *argp2 ;
96270   bool result;
96271
96272   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96273   argp2 = (Dali::Toolkit::Button *)jarg2;
96274   if (!argp2) {
96275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96276     return 0;
96277   }
96278   arg2 = *argp2;
96279   {
96280     try {
96281       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96282     } catch (std::out_of_range& e) {
96283       {
96284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96285       };
96286     } catch (std::exception& e) {
96287       {
96288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96289       };
96290     } catch (Dali::DaliException e) {
96291       {
96292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96293       };
96294     } catch (...) {
96295       {
96296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96297       };
96298     }
96299   }
96300
96301   jresult = result;
96302   return jresult;
96303 }
96304
96305
96306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96307   void * jresult ;
96308   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96309
96310   {
96311     try {
96312       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96313     } catch (std::out_of_range& e) {
96314       {
96315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96316       };
96317     } catch (std::exception& e) {
96318       {
96319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96320       };
96321     } catch (Dali::DaliException e) {
96322       {
96323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96324       };
96325     } catch (...) {
96326       {
96327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96328       };
96329     }
96330   }
96331
96332   jresult = (void *)result;
96333   return jresult;
96334 }
96335
96336
96337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96338   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96339
96340   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96341   {
96342     try {
96343       delete arg1;
96344     } catch (std::out_of_range& e) {
96345       {
96346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96347       };
96348     } catch (std::exception& e) {
96349       {
96350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96351       };
96352     } catch (Dali::DaliException e) {
96353       {
96354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96355       };
96356     } catch (...) {
96357       {
96358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96359       };
96360     }
96361   }
96362
96363 }
96364
96365
96366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96367   unsigned int jresult ;
96368   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96369   bool result;
96370
96371   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96372   {
96373     try {
96374       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96375     } catch (std::out_of_range& e) {
96376       {
96377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96378       };
96379     } catch (std::exception& e) {
96380       {
96381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96382       };
96383     } catch (Dali::DaliException e) {
96384       {
96385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96386       };
96387     } catch (...) {
96388       {
96389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96390       };
96391     }
96392   }
96393
96394   jresult = result;
96395   return jresult;
96396 }
96397
96398
96399 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96400   unsigned long jresult ;
96401   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96402   std::size_t result;
96403
96404   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96405   {
96406     try {
96407       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96408     } catch (std::out_of_range& e) {
96409       {
96410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96411       };
96412     } catch (std::exception& e) {
96413       {
96414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96415       };
96416     } catch (Dali::DaliException e) {
96417       {
96418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96419       };
96420     } catch (...) {
96421       {
96422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96423       };
96424     }
96425   }
96426
96427   jresult = (unsigned long)result;
96428   return jresult;
96429 }
96430
96431
96432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96433   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96434   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96435
96436   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96437   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96438   {
96439     try {
96440       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96441     } catch (std::out_of_range& e) {
96442       {
96443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96444       };
96445     } catch (std::exception& e) {
96446       {
96447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96448       };
96449     } catch (Dali::DaliException e) {
96450       {
96451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96452       };
96453     } catch (...) {
96454       {
96455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96456       };
96457     }
96458   }
96459
96460 }
96461
96462
96463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96464   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96465   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96466
96467   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96468   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96469   {
96470     try {
96471       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96472     } catch (std::out_of_range& e) {
96473       {
96474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96475       };
96476     } catch (std::exception& e) {
96477       {
96478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96479       };
96480     } catch (Dali::DaliException e) {
96481       {
96482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96483       };
96484     } catch (...) {
96485       {
96486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96487       };
96488     }
96489   }
96490
96491 }
96492
96493
96494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96495   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96496   Dali::Toolkit::GaussianBlurView arg2 ;
96497   Dali::Toolkit::GaussianBlurView *argp2 ;
96498
96499   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96500   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96501   if (!argp2) {
96502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96503     return ;
96504   }
96505   arg2 = *argp2;
96506   {
96507     try {
96508       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96509     } catch (std::out_of_range& e) {
96510       {
96511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96512       };
96513     } catch (std::exception& e) {
96514       {
96515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96516       };
96517     } catch (Dali::DaliException e) {
96518       {
96519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96520       };
96521     } catch (...) {
96522       {
96523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96524       };
96525     }
96526   }
96527
96528 }
96529
96530
96531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96532   void * jresult ;
96533   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96534
96535   {
96536     try {
96537       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96538     } catch (std::out_of_range& e) {
96539       {
96540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96541       };
96542     } catch (std::exception& e) {
96543       {
96544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96545       };
96546     } catch (Dali::DaliException e) {
96547       {
96548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96549       };
96550     } catch (...) {
96551       {
96552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96553       };
96554     }
96555   }
96556
96557   jresult = (void *)result;
96558   return jresult;
96559 }
96560
96561
96562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96563   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96564
96565   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96566   {
96567     try {
96568       delete arg1;
96569     } catch (std::out_of_range& e) {
96570       {
96571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96572       };
96573     } catch (std::exception& e) {
96574       {
96575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96576       };
96577     } catch (Dali::DaliException e) {
96578       {
96579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96580       };
96581     } catch (...) {
96582       {
96583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96584       };
96585     }
96586   }
96587
96588 }
96589
96590
96591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96592   unsigned int jresult ;
96593   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96594   bool result;
96595
96596   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96597   {
96598     try {
96599       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);
96600     } catch (std::out_of_range& e) {
96601       {
96602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96603       };
96604     } catch (std::exception& e) {
96605       {
96606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96607       };
96608     } catch (Dali::DaliException e) {
96609       {
96610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96611       };
96612     } catch (...) {
96613       {
96614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96615       };
96616     }
96617   }
96618
96619   jresult = result;
96620   return jresult;
96621 }
96622
96623
96624 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96625   unsigned long jresult ;
96626   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96627   std::size_t result;
96628
96629   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96630   {
96631     try {
96632       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);
96633     } catch (std::out_of_range& e) {
96634       {
96635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96636       };
96637     } catch (std::exception& e) {
96638       {
96639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96640       };
96641     } catch (Dali::DaliException e) {
96642       {
96643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96644       };
96645     } catch (...) {
96646       {
96647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96648       };
96649     }
96650   }
96651
96652   jresult = (unsigned long)result;
96653   return jresult;
96654 }
96655
96656
96657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
96658   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96659   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96660
96661   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96662   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96663   {
96664     try {
96665       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
96666     } catch (std::out_of_range& e) {
96667       {
96668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96669       };
96670     } catch (std::exception& e) {
96671       {
96672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96673       };
96674     } catch (Dali::DaliException e) {
96675       {
96676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96677       };
96678     } catch (...) {
96679       {
96680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96681       };
96682     }
96683   }
96684
96685 }
96686
96687
96688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
96689   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96690   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96691
96692   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96693   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96694   {
96695     try {
96696       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96697     } catch (std::out_of_range& e) {
96698       {
96699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96700       };
96701     } catch (std::exception& e) {
96702       {
96703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96704       };
96705     } catch (Dali::DaliException e) {
96706       {
96707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96708       };
96709     } catch (...) {
96710       {
96711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96712       };
96713     }
96714   }
96715
96716 }
96717
96718
96719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
96720   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96721   Dali::Toolkit::PageTurnView arg2 ;
96722   unsigned int arg3 ;
96723   bool arg4 ;
96724   Dali::Toolkit::PageTurnView *argp2 ;
96725
96726   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96727   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96728   if (!argp2) {
96729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96730     return ;
96731   }
96732   arg2 = *argp2;
96733   arg3 = (unsigned int)jarg3;
96734   arg4 = jarg4 ? true : false;
96735   {
96736     try {
96737       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96738     } catch (std::out_of_range& e) {
96739       {
96740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96741       };
96742     } catch (std::exception& e) {
96743       {
96744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96745       };
96746     } catch (Dali::DaliException e) {
96747       {
96748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96749       };
96750     } catch (...) {
96751       {
96752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96753       };
96754     }
96755   }
96756
96757 }
96758
96759
96760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
96761   void * jresult ;
96762   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
96763
96764   {
96765     try {
96766       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
96767     } catch (std::out_of_range& e) {
96768       {
96769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96770       };
96771     } catch (std::exception& e) {
96772       {
96773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96774       };
96775     } catch (Dali::DaliException e) {
96776       {
96777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96778       };
96779     } catch (...) {
96780       {
96781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96782       };
96783     }
96784   }
96785
96786   jresult = (void *)result;
96787   return jresult;
96788 }
96789
96790
96791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
96792   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96793
96794   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96795   {
96796     try {
96797       delete arg1;
96798     } catch (std::out_of_range& e) {
96799       {
96800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96801       };
96802     } catch (std::exception& e) {
96803       {
96804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96805       };
96806     } catch (Dali::DaliException e) {
96807       {
96808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96809       };
96810     } catch (...) {
96811       {
96812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96813       };
96814     }
96815   }
96816
96817 }
96818
96819
96820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
96821   unsigned int jresult ;
96822   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96823   bool result;
96824
96825   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96826   {
96827     try {
96828       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96829     } catch (std::out_of_range& e) {
96830       {
96831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96832       };
96833     } catch (std::exception& e) {
96834       {
96835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96836       };
96837     } catch (Dali::DaliException e) {
96838       {
96839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96840       };
96841     } catch (...) {
96842       {
96843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96844       };
96845     }
96846   }
96847
96848   jresult = result;
96849   return jresult;
96850 }
96851
96852
96853 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
96854   unsigned long jresult ;
96855   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96856   std::size_t result;
96857
96858   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96859   {
96860     try {
96861       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96862     } catch (std::out_of_range& e) {
96863       {
96864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96865       };
96866     } catch (std::exception& e) {
96867       {
96868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96869       };
96870     } catch (Dali::DaliException e) {
96871       {
96872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96873       };
96874     } catch (...) {
96875       {
96876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96877       };
96878     }
96879   }
96880
96881   jresult = (unsigned long)result;
96882   return jresult;
96883 }
96884
96885
96886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
96887   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96888   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96889
96890   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96891   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96892   {
96893     try {
96894       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
96895     } catch (std::out_of_range& e) {
96896       {
96897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96898       };
96899     } catch (std::exception& e) {
96900       {
96901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96902       };
96903     } catch (Dali::DaliException e) {
96904       {
96905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96906       };
96907     } catch (...) {
96908       {
96909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96910       };
96911     }
96912   }
96913
96914 }
96915
96916
96917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
96918   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96919   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96920
96921   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96922   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96923   {
96924     try {
96925       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
96926     } catch (std::out_of_range& e) {
96927       {
96928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96929       };
96930     } catch (std::exception& e) {
96931       {
96932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96933       };
96934     } catch (Dali::DaliException e) {
96935       {
96936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96937       };
96938     } catch (...) {
96939       {
96940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96941       };
96942     }
96943   }
96944
96945 }
96946
96947
96948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96949   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96950   Dali::Toolkit::PageTurnView arg2 ;
96951   Dali::Toolkit::PageTurnView *argp2 ;
96952
96953   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96954   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96955   if (!argp2) {
96956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96957     return ;
96958   }
96959   arg2 = *argp2;
96960   {
96961     try {
96962       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96963     } catch (std::out_of_range& e) {
96964       {
96965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96966       };
96967     } catch (std::exception& e) {
96968       {
96969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96970       };
96971     } catch (Dali::DaliException e) {
96972       {
96973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96974       };
96975     } catch (...) {
96976       {
96977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96978       };
96979     }
96980   }
96981
96982 }
96983
96984
96985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96986   void * jresult ;
96987   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96988
96989   {
96990     try {
96991       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96992     } catch (std::out_of_range& e) {
96993       {
96994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96995       };
96996     } catch (std::exception& e) {
96997       {
96998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96999       };
97000     } catch (Dali::DaliException e) {
97001       {
97002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97003       };
97004     } catch (...) {
97005       {
97006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97007       };
97008     }
97009   }
97010
97011   jresult = (void *)result;
97012   return jresult;
97013 }
97014
97015
97016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97017   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97018
97019   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97020   {
97021     try {
97022       delete arg1;
97023     } catch (std::out_of_range& e) {
97024       {
97025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97026       };
97027     } catch (std::exception& e) {
97028       {
97029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97030       };
97031     } catch (Dali::DaliException e) {
97032       {
97033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97034       };
97035     } catch (...) {
97036       {
97037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97038       };
97039     }
97040   }
97041
97042 }
97043
97044
97045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97046   unsigned int jresult ;
97047   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97048   bool result;
97049
97050   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97051   {
97052     try {
97053       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);
97054     } catch (std::out_of_range& e) {
97055       {
97056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97057       };
97058     } catch (std::exception& e) {
97059       {
97060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97061       };
97062     } catch (Dali::DaliException e) {
97063       {
97064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97065       };
97066     } catch (...) {
97067       {
97068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97069       };
97070     }
97071   }
97072
97073   jresult = result;
97074   return jresult;
97075 }
97076
97077
97078 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97079   unsigned long jresult ;
97080   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97081   std::size_t result;
97082
97083   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97084   {
97085     try {
97086       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);
97087     } catch (std::out_of_range& e) {
97088       {
97089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97090       };
97091     } catch (std::exception& e) {
97092       {
97093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97094       };
97095     } catch (Dali::DaliException e) {
97096       {
97097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97098       };
97099     } catch (...) {
97100       {
97101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97102       };
97103     }
97104   }
97105
97106   jresult = (unsigned long)result;
97107   return jresult;
97108 }
97109
97110
97111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97112   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97113   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97114
97115   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97116   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97117   {
97118     try {
97119       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97120     } catch (std::out_of_range& e) {
97121       {
97122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97123       };
97124     } catch (std::exception& e) {
97125       {
97126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97127       };
97128     } catch (Dali::DaliException e) {
97129       {
97130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97131       };
97132     } catch (...) {
97133       {
97134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97135       };
97136     }
97137   }
97138
97139 }
97140
97141
97142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97143   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97144   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97145
97146   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97147   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97148   {
97149     try {
97150       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97174   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97175   Dali::Toolkit::ProgressBar arg2 ;
97176   float arg3 ;
97177   float arg4 ;
97178   Dali::Toolkit::ProgressBar *argp2 ;
97179
97180   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97181   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97182   if (!argp2) {
97183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97184     return ;
97185   }
97186   arg2 = *argp2;
97187   arg3 = (float)jarg3;
97188   arg4 = (float)jarg4;
97189   {
97190     try {
97191       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97192     } catch (std::out_of_range& e) {
97193       {
97194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97195       };
97196     } catch (std::exception& e) {
97197       {
97198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97199       };
97200     } catch (Dali::DaliException e) {
97201       {
97202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97203       };
97204     } catch (...) {
97205       {
97206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97207       };
97208     }
97209   }
97210
97211 }
97212
97213
97214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97215   void * jresult ;
97216   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97217
97218   {
97219     try {
97220       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97221     } catch (std::out_of_range& e) {
97222       {
97223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97224       };
97225     } catch (std::exception& e) {
97226       {
97227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97228       };
97229     } catch (Dali::DaliException e) {
97230       {
97231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97232       };
97233     } catch (...) {
97234       {
97235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97236       };
97237     }
97238   }
97239
97240   jresult = (void *)result;
97241   return jresult;
97242 }
97243
97244
97245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97246   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97247
97248   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97249   {
97250     try {
97251       delete arg1;
97252     } catch (std::out_of_range& e) {
97253       {
97254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97255       };
97256     } catch (std::exception& e) {
97257       {
97258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97259       };
97260     } catch (Dali::DaliException e) {
97261       {
97262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97263       };
97264     } catch (...) {
97265       {
97266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97267       };
97268     }
97269   }
97270
97271 }
97272
97273
97274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97275   unsigned int jresult ;
97276   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97277   bool result;
97278
97279   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97280   {
97281     try {
97282       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);
97283     } catch (std::out_of_range& e) {
97284       {
97285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97286       };
97287     } catch (std::exception& e) {
97288       {
97289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97290       };
97291     } catch (Dali::DaliException e) {
97292       {
97293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97294       };
97295     } catch (...) {
97296       {
97297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97298       };
97299     }
97300   }
97301
97302   jresult = result;
97303   return jresult;
97304 }
97305
97306
97307 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97308   unsigned long jresult ;
97309   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97310   std::size_t result;
97311
97312   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97313   {
97314     try {
97315       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);
97316     } catch (std::out_of_range& e) {
97317       {
97318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97319       };
97320     } catch (std::exception& e) {
97321       {
97322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97323       };
97324     } catch (Dali::DaliException e) {
97325       {
97326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97327       };
97328     } catch (...) {
97329       {
97330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97331       };
97332     }
97333   }
97334
97335   jresult = (unsigned long)result;
97336   return jresult;
97337 }
97338
97339
97340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97341   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97342   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97343
97344   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97345   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97346   {
97347     try {
97348       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97349     } catch (std::out_of_range& e) {
97350       {
97351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97352       };
97353     } catch (std::exception& e) {
97354       {
97355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97356       };
97357     } catch (Dali::DaliException e) {
97358       {
97359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97360       };
97361     } catch (...) {
97362       {
97363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97364       };
97365     }
97366   }
97367
97368 }
97369
97370
97371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97372   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97373   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97374
97375   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97376   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97377   {
97378     try {
97379       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97380     } catch (std::out_of_range& e) {
97381       {
97382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97383       };
97384     } catch (std::exception& e) {
97385       {
97386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97387       };
97388     } catch (Dali::DaliException e) {
97389       {
97390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97391       };
97392     } catch (...) {
97393       {
97394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97395       };
97396     }
97397   }
97398
97399 }
97400
97401
97402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97403   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97404   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97405
97406   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97407   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97408   if (!arg2) {
97409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97410     return ;
97411   }
97412   {
97413     try {
97414       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97415     } catch (std::out_of_range& e) {
97416       {
97417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97418       };
97419     } catch (std::exception& e) {
97420       {
97421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97422       };
97423     } catch (Dali::DaliException e) {
97424       {
97425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97426       };
97427     } catch (...) {
97428       {
97429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97430       };
97431     }
97432   }
97433
97434 }
97435
97436
97437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97438   void * jresult ;
97439   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97440
97441   {
97442     try {
97443       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97444     } catch (std::out_of_range& e) {
97445       {
97446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97447       };
97448     } catch (std::exception& e) {
97449       {
97450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97451       };
97452     } catch (Dali::DaliException e) {
97453       {
97454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97455       };
97456     } catch (...) {
97457       {
97458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97459       };
97460     }
97461   }
97462
97463   jresult = (void *)result;
97464   return jresult;
97465 }
97466
97467
97468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97469   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97470
97471   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97472   {
97473     try {
97474       delete arg1;
97475     } catch (std::out_of_range& e) {
97476       {
97477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97478       };
97479     } catch (std::exception& e) {
97480       {
97481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97482       };
97483     } catch (Dali::DaliException e) {
97484       {
97485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97486       };
97487     } catch (...) {
97488       {
97489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97490       };
97491     }
97492   }
97493
97494 }
97495
97496
97497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97498   unsigned int jresult ;
97499   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97500   bool result;
97501
97502   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97503   {
97504     try {
97505       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97506     } catch (std::out_of_range& e) {
97507       {
97508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97509       };
97510     } catch (std::exception& e) {
97511       {
97512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97513       };
97514     } catch (Dali::DaliException e) {
97515       {
97516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97517       };
97518     } catch (...) {
97519       {
97520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97521       };
97522     }
97523   }
97524
97525   jresult = result;
97526   return jresult;
97527 }
97528
97529
97530 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97531   unsigned long jresult ;
97532   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97533   std::size_t result;
97534
97535   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97536   {
97537     try {
97538       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97539     } catch (std::out_of_range& e) {
97540       {
97541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97542       };
97543     } catch (std::exception& e) {
97544       {
97545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97546       };
97547     } catch (Dali::DaliException e) {
97548       {
97549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97550       };
97551     } catch (...) {
97552       {
97553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97554       };
97555     }
97556   }
97557
97558   jresult = (unsigned long)result;
97559   return jresult;
97560 }
97561
97562
97563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97564   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97565   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97566
97567   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97568   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97569   {
97570     try {
97571       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97572     } catch (std::out_of_range& e) {
97573       {
97574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97575       };
97576     } catch (std::exception& e) {
97577       {
97578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97579       };
97580     } catch (Dali::DaliException e) {
97581       {
97582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97583       };
97584     } catch (...) {
97585       {
97586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97587       };
97588     }
97589   }
97590
97591 }
97592
97593
97594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97595   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97596   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97597
97598   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97599   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97600   {
97601     try {
97602       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97603     } catch (std::out_of_range& e) {
97604       {
97605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97606       };
97607     } catch (std::exception& e) {
97608       {
97609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97610       };
97611     } catch (Dali::DaliException e) {
97612       {
97613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97614       };
97615     } catch (...) {
97616       {
97617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97618       };
97619     }
97620   }
97621
97622 }
97623
97624
97625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97626   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97627   Dali::Vector2 *arg2 = 0 ;
97628
97629   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97630   arg2 = (Dali::Vector2 *)jarg2;
97631   if (!arg2) {
97632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97633     return ;
97634   }
97635   {
97636     try {
97637       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97638     } catch (std::out_of_range& e) {
97639       {
97640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97641       };
97642     } catch (std::exception& e) {
97643       {
97644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97645       };
97646     } catch (Dali::DaliException e) {
97647       {
97648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97649       };
97650     } catch (...) {
97651       {
97652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97653       };
97654     }
97655   }
97656
97657 }
97658
97659
97660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
97661   void * jresult ;
97662   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
97663
97664   {
97665     try {
97666       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
97667     } catch (std::out_of_range& e) {
97668       {
97669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97670       };
97671     } catch (std::exception& e) {
97672       {
97673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97674       };
97675     } catch (Dali::DaliException e) {
97676       {
97677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97678       };
97679     } catch (...) {
97680       {
97681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97682       };
97683     }
97684   }
97685
97686   jresult = (void *)result;
97687   return jresult;
97688 }
97689
97690
97691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
97692   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97693
97694   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97695   {
97696     try {
97697       delete arg1;
97698     } catch (std::out_of_range& e) {
97699       {
97700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97701       };
97702     } catch (std::exception& e) {
97703       {
97704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97705       };
97706     } catch (Dali::DaliException e) {
97707       {
97708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97709       };
97710     } catch (...) {
97711       {
97712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97713       };
97714     }
97715   }
97716
97717 }
97718
97719
97720
97721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
97722   unsigned int jresult ;
97723   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97724   bool result;
97725
97726   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97727   {
97728     try {
97729       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);
97730     } catch (std::out_of_range& e) {
97731       {
97732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97733       };
97734     } catch (std::exception& e) {
97735       {
97736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97737       };
97738     } catch (Dali::DaliException e) {
97739       {
97740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97741       };
97742     } catch (...) {
97743       {
97744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97745       };
97746     }
97747   }
97748
97749   jresult = result;
97750   return jresult;
97751 }
97752
97753
97754 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
97755   unsigned long jresult ;
97756   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97757   std::size_t result;
97758
97759   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97760   {
97761     try {
97762       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);
97763     } catch (std::out_of_range& e) {
97764       {
97765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97766       };
97767     } catch (std::exception& e) {
97768       {
97769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97770       };
97771     } catch (Dali::DaliException e) {
97772       {
97773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97774       };
97775     } catch (...) {
97776       {
97777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97778       };
97779     }
97780   }
97781
97782   jresult = (unsigned long)result;
97783   return jresult;
97784 }
97785
97786
97787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97788   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97789   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97790
97791   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97792   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97793   {
97794     try {
97795       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97796     } catch (std::out_of_range& e) {
97797       {
97798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97799       };
97800     } catch (std::exception& e) {
97801       {
97802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97803       };
97804     } catch (Dali::DaliException e) {
97805       {
97806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97807       };
97808     } catch (...) {
97809       {
97810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97811       };
97812     }
97813   }
97814
97815 }
97816
97817
97818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
97819   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97820   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97821
97822   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97823   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97824   {
97825     try {
97826       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97827     } catch (std::out_of_range& e) {
97828       {
97829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97830       };
97831     } catch (std::exception& e) {
97832       {
97833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97834       };
97835     } catch (Dali::DaliException e) {
97836       {
97837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97838       };
97839     } catch (...) {
97840       {
97841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97842       };
97843     }
97844   }
97845
97846 }
97847
97848
97849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
97850   unsigned int jresult ;
97851   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97852   Dali::Toolkit::Control arg2 ;
97853   Dali::KeyEvent *arg3 = 0 ;
97854   Dali::Toolkit::Control *argp2 ;
97855   bool result;
97856
97857   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97858   argp2 = (Dali::Toolkit::Control *)jarg2;
97859   if (!argp2) {
97860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97861     return 0;
97862   }
97863   arg2 = *argp2;
97864   arg3 = (Dali::KeyEvent *)jarg3;
97865   if (!arg3) {
97866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
97867     return 0;
97868   }
97869   {
97870     try {
97871       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);
97872     } catch (std::out_of_range& e) {
97873       {
97874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97875       };
97876     } catch (std::exception& e) {
97877       {
97878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97879       };
97880     } catch (Dali::DaliException e) {
97881       {
97882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97883       };
97884     } catch (...) {
97885       {
97886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97887       };
97888     }
97889   }
97890
97891   jresult = result;
97892   return jresult;
97893 }
97894
97895
97896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
97897   void * jresult ;
97898   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
97899
97900   {
97901     try {
97902       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
97903     } catch (std::out_of_range& e) {
97904       {
97905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97906       };
97907     } catch (std::exception& e) {
97908       {
97909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97910       };
97911     } catch (Dali::DaliException e) {
97912       {
97913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97914       };
97915     } catch (...) {
97916       {
97917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97918       };
97919     }
97920   }
97921
97922   jresult = (void *)result;
97923   return jresult;
97924 }
97925
97926
97927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
97928   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97929
97930   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97931   {
97932     try {
97933       delete arg1;
97934     } catch (std::out_of_range& e) {
97935       {
97936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97937       };
97938     } catch (std::exception& e) {
97939       {
97940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97941       };
97942     } catch (Dali::DaliException e) {
97943       {
97944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97945       };
97946     } catch (...) {
97947       {
97948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97949       };
97950     }
97951   }
97952
97953 }
97954
97955
97956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97957   unsigned int jresult ;
97958   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97959   bool result;
97960
97961   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97962   {
97963     try {
97964       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97965     } catch (std::out_of_range& e) {
97966       {
97967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97968       };
97969     } catch (std::exception& e) {
97970       {
97971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97972       };
97973     } catch (Dali::DaliException e) {
97974       {
97975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97976       };
97977     } catch (...) {
97978       {
97979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97980       };
97981     }
97982   }
97983
97984   jresult = result;
97985   return jresult;
97986 }
97987
97988
97989 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97990   unsigned long jresult ;
97991   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97992   std::size_t result;
97993
97994   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97995   {
97996     try {
97997       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97998     } catch (std::out_of_range& e) {
97999       {
98000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98001       };
98002     } catch (std::exception& e) {
98003       {
98004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98005       };
98006     } catch (Dali::DaliException e) {
98007       {
98008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98009       };
98010     } catch (...) {
98011       {
98012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98013       };
98014     }
98015   }
98016
98017   jresult = (unsigned long)result;
98018   return jresult;
98019 }
98020
98021
98022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98023   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98024   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98025
98026   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98027   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98028   {
98029     try {
98030       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98031     } catch (std::out_of_range& e) {
98032       {
98033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98034       };
98035     } catch (std::exception& e) {
98036       {
98037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98038       };
98039     } catch (Dali::DaliException e) {
98040       {
98041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98042       };
98043     } catch (...) {
98044       {
98045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98046       };
98047     }
98048   }
98049
98050 }
98051
98052
98053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98054   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98055   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98056
98057   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98058   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98059   {
98060     try {
98061       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98062     } catch (std::out_of_range& e) {
98063       {
98064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98065       };
98066     } catch (std::exception& e) {
98067       {
98068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98069       };
98070     } catch (Dali::DaliException e) {
98071       {
98072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98073       };
98074     } catch (...) {
98075       {
98076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98077       };
98078     }
98079   }
98080
98081 }
98082
98083
98084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98085   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98086   Dali::Toolkit::Control arg2 ;
98087   Dali::Toolkit::Control *argp2 ;
98088
98089   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98090   argp2 = (Dali::Toolkit::Control *)jarg2;
98091   if (!argp2) {
98092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98093     return ;
98094   }
98095   arg2 = *argp2;
98096   {
98097     try {
98098       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98099     } catch (std::out_of_range& e) {
98100       {
98101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98102       };
98103     } catch (std::exception& e) {
98104       {
98105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98106       };
98107     } catch (Dali::DaliException e) {
98108       {
98109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98110       };
98111     } catch (...) {
98112       {
98113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98114       };
98115     }
98116   }
98117
98118 }
98119
98120
98121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98122   void * jresult ;
98123   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98124
98125   {
98126     try {
98127       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98128     } catch (std::out_of_range& e) {
98129       {
98130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98131       };
98132     } catch (std::exception& e) {
98133       {
98134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98135       };
98136     } catch (Dali::DaliException e) {
98137       {
98138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98139       };
98140     } catch (...) {
98141       {
98142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98143       };
98144     }
98145   }
98146
98147   jresult = (void *)result;
98148   return jresult;
98149 }
98150
98151
98152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98153   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98154
98155   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98156   {
98157     try {
98158       delete arg1;
98159     } catch (std::out_of_range& e) {
98160       {
98161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98162       };
98163     } catch (std::exception& e) {
98164       {
98165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98166       };
98167     } catch (Dali::DaliException e) {
98168       {
98169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98170       };
98171     } catch (...) {
98172       {
98173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98174       };
98175     }
98176   }
98177
98178 }
98179
98180
98181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98182   unsigned int jresult ;
98183   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98184   bool result;
98185
98186   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98187   {
98188     try {
98189       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98190     } catch (std::out_of_range& e) {
98191       {
98192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98193       };
98194     } catch (std::exception& e) {
98195       {
98196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98197       };
98198     } catch (Dali::DaliException e) {
98199       {
98200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98201       };
98202     } catch (...) {
98203       {
98204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98205       };
98206     }
98207   }
98208
98209   jresult = result;
98210   return jresult;
98211 }
98212
98213
98214 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98215   unsigned long jresult ;
98216   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98217   std::size_t result;
98218
98219   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98220   {
98221     try {
98222       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98223     } catch (std::out_of_range& e) {
98224       {
98225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98226       };
98227     } catch (std::exception& e) {
98228       {
98229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98230       };
98231     } catch (Dali::DaliException e) {
98232       {
98233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98234       };
98235     } catch (...) {
98236       {
98237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98238       };
98239     }
98240   }
98241
98242   jresult = (unsigned long)result;
98243   return jresult;
98244 }
98245
98246
98247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98248   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98249   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98250
98251   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98252   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98253   {
98254     try {
98255       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98256     } catch (std::out_of_range& e) {
98257       {
98258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98259       };
98260     } catch (std::exception& e) {
98261       {
98262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98263       };
98264     } catch (Dali::DaliException e) {
98265       {
98266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98267       };
98268     } catch (...) {
98269       {
98270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98271       };
98272     }
98273   }
98274
98275 }
98276
98277
98278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98279   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98280   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98281
98282   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98283   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98284   {
98285     try {
98286       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98287     } catch (std::out_of_range& e) {
98288       {
98289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98290       };
98291     } catch (std::exception& e) {
98292       {
98293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98294       };
98295     } catch (Dali::DaliException e) {
98296       {
98297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98298       };
98299     } catch (...) {
98300       {
98301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98302       };
98303     }
98304   }
98305
98306 }
98307
98308
98309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98310   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98311   Dali::Toolkit::VideoView *arg2 = 0 ;
98312
98313   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98314   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98315   if (!arg2) {
98316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98317     return ;
98318   }
98319   {
98320     try {
98321       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98322     } catch (std::out_of_range& e) {
98323       {
98324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98325       };
98326     } catch (std::exception& e) {
98327       {
98328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98329       };
98330     } catch (Dali::DaliException e) {
98331       {
98332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98333       };
98334     } catch (...) {
98335       {
98336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98337       };
98338     }
98339   }
98340
98341 }
98342
98343
98344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98345   void * jresult ;
98346   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98347
98348   {
98349     try {
98350       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98351     } catch (std::out_of_range& e) {
98352       {
98353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98354       };
98355     } catch (std::exception& e) {
98356       {
98357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98358       };
98359     } catch (Dali::DaliException e) {
98360       {
98361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98362       };
98363     } catch (...) {
98364       {
98365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98366       };
98367     }
98368   }
98369
98370   jresult = (void *)result;
98371   return jresult;
98372 }
98373
98374
98375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98376   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98377
98378   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98379   {
98380     try {
98381       delete arg1;
98382     } catch (std::out_of_range& e) {
98383       {
98384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98385       };
98386     } catch (std::exception& e) {
98387       {
98388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98389       };
98390     } catch (Dali::DaliException e) {
98391       {
98392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98393       };
98394     } catch (...) {
98395       {
98396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98397       };
98398     }
98399   }
98400
98401 }
98402
98403
98404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98405   unsigned int jresult ;
98406   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98407   bool result;
98408
98409   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98410   {
98411     try {
98412       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98413     } catch (std::out_of_range& e) {
98414       {
98415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98416       };
98417     } catch (std::exception& e) {
98418       {
98419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98420       };
98421     } catch (Dali::DaliException e) {
98422       {
98423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98424       };
98425     } catch (...) {
98426       {
98427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98428       };
98429     }
98430   }
98431
98432   jresult = result;
98433   return jresult;
98434 }
98435
98436
98437 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98438   unsigned long jresult ;
98439   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98440   std::size_t result;
98441
98442   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98443   {
98444     try {
98445       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98446     } catch (std::out_of_range& e) {
98447       {
98448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98449       };
98450     } catch (std::exception& e) {
98451       {
98452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98453       };
98454     } catch (Dali::DaliException e) {
98455       {
98456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98457       };
98458     } catch (...) {
98459       {
98460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98461       };
98462     }
98463   }
98464
98465   jresult = (unsigned long)result;
98466   return jresult;
98467 }
98468
98469
98470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98471   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98472   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98473
98474   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98475   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98476   {
98477     try {
98478       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98479     } catch (std::out_of_range& e) {
98480       {
98481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98482       };
98483     } catch (std::exception& e) {
98484       {
98485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98486       };
98487     } catch (Dali::DaliException e) {
98488       {
98489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98490       };
98491     } catch (...) {
98492       {
98493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98494       };
98495     }
98496   }
98497
98498 }
98499
98500
98501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98502   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98503   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98504
98505   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98506   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98507   {
98508     try {
98509       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98510     } catch (std::out_of_range& e) {
98511       {
98512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98513       };
98514     } catch (std::exception& e) {
98515       {
98516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98517       };
98518     } catch (Dali::DaliException e) {
98519       {
98520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98521       };
98522     } catch (...) {
98523       {
98524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98525       };
98526     }
98527   }
98528
98529 }
98530
98531
98532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98533   unsigned int jresult ;
98534   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98535   Dali::Toolkit::Slider arg2 ;
98536   float arg3 ;
98537   Dali::Toolkit::Slider *argp2 ;
98538   bool result;
98539
98540   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98541   argp2 = (Dali::Toolkit::Slider *)jarg2;
98542   if (!argp2) {
98543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98544     return 0;
98545   }
98546   arg2 = *argp2;
98547   arg3 = (float)jarg3;
98548   {
98549     try {
98550       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98551     } catch (std::out_of_range& e) {
98552       {
98553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98554       };
98555     } catch (std::exception& e) {
98556       {
98557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98558       };
98559     } catch (Dali::DaliException e) {
98560       {
98561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98562       };
98563     } catch (...) {
98564       {
98565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98566       };
98567     }
98568   }
98569
98570   jresult = result;
98571   return jresult;
98572 }
98573
98574
98575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98576   void * jresult ;
98577   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98578
98579   {
98580     try {
98581       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98582     } catch (std::out_of_range& e) {
98583       {
98584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98585       };
98586     } catch (std::exception& e) {
98587       {
98588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98589       };
98590     } catch (Dali::DaliException e) {
98591       {
98592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98593       };
98594     } catch (...) {
98595       {
98596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98597       };
98598     }
98599   }
98600
98601   jresult = (void *)result;
98602   return jresult;
98603 }
98604
98605
98606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98607   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98608
98609   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98610   {
98611     try {
98612       delete arg1;
98613     } catch (std::out_of_range& e) {
98614       {
98615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98616       };
98617     } catch (std::exception& e) {
98618       {
98619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98620       };
98621     } catch (Dali::DaliException e) {
98622       {
98623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98624       };
98625     } catch (...) {
98626       {
98627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98628       };
98629     }
98630   }
98631
98632 }
98633
98634
98635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98636   unsigned int jresult ;
98637   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98638   bool result;
98639
98640   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98641   {
98642     try {
98643       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98644     } catch (std::out_of_range& e) {
98645       {
98646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98647       };
98648     } catch (std::exception& e) {
98649       {
98650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98651       };
98652     } catch (Dali::DaliException e) {
98653       {
98654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98655       };
98656     } catch (...) {
98657       {
98658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98659       };
98660     }
98661   }
98662
98663   jresult = result;
98664   return jresult;
98665 }
98666
98667
98668 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
98669   unsigned long jresult ;
98670   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98671   std::size_t result;
98672
98673   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98674   {
98675     try {
98676       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98677     } catch (std::out_of_range& e) {
98678       {
98679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98680       };
98681     } catch (std::exception& e) {
98682       {
98683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98684       };
98685     } catch (Dali::DaliException e) {
98686       {
98687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98688       };
98689     } catch (...) {
98690       {
98691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98692       };
98693     }
98694   }
98695
98696   jresult = (unsigned long)result;
98697   return jresult;
98698 }
98699
98700
98701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
98702   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98703   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98704
98705   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98706   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98707   {
98708     try {
98709       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
98710     } catch (std::out_of_range& e) {
98711       {
98712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98713       };
98714     } catch (std::exception& e) {
98715       {
98716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98717       };
98718     } catch (Dali::DaliException e) {
98719       {
98720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98721       };
98722     } catch (...) {
98723       {
98724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98725       };
98726     }
98727   }
98728
98729 }
98730
98731
98732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
98733   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98734   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98735
98736   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98737   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98738   {
98739     try {
98740       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
98741     } catch (std::out_of_range& e) {
98742       {
98743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98744       };
98745     } catch (std::exception& e) {
98746       {
98747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98748       };
98749     } catch (Dali::DaliException e) {
98750       {
98751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98752       };
98753     } catch (...) {
98754       {
98755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98756       };
98757     }
98758   }
98759
98760 }
98761
98762
98763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
98764   unsigned int jresult ;
98765   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98766   Dali::Toolkit::Slider arg2 ;
98767   int arg3 ;
98768   Dali::Toolkit::Slider *argp2 ;
98769   bool result;
98770
98771   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98772   argp2 = (Dali::Toolkit::Slider *)jarg2;
98773   if (!argp2) {
98774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98775     return 0;
98776   }
98777   arg2 = *argp2;
98778   arg3 = (int)jarg3;
98779   {
98780     try {
98781       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
98782     } catch (std::out_of_range& e) {
98783       {
98784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98785       };
98786     } catch (std::exception& e) {
98787       {
98788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98789       };
98790     } catch (Dali::DaliException e) {
98791       {
98792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98793       };
98794     } catch (...) {
98795       {
98796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98797       };
98798     }
98799   }
98800
98801   jresult = result;
98802   return jresult;
98803 }
98804
98805
98806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
98807   void * jresult ;
98808   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
98809
98810   {
98811     try {
98812       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
98813     } catch (std::out_of_range& e) {
98814       {
98815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98816       };
98817     } catch (std::exception& e) {
98818       {
98819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98820       };
98821     } catch (Dali::DaliException e) {
98822       {
98823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98824       };
98825     } catch (...) {
98826       {
98827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98828       };
98829     }
98830   }
98831
98832   jresult = (void *)result;
98833   return jresult;
98834 }
98835
98836
98837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
98838   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98839
98840   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98841   {
98842     try {
98843       delete arg1;
98844     } catch (std::out_of_range& e) {
98845       {
98846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98847       };
98848     } catch (std::exception& e) {
98849       {
98850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98851       };
98852     } catch (Dali::DaliException e) {
98853       {
98854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98855       };
98856     } catch (...) {
98857       {
98858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98859       };
98860     }
98861   }
98862
98863 }
98864
98865
98866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
98867   void * jresult ;
98868   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98869
98870   {
98871     try {
98872       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
98873     } catch (std::out_of_range& e) {
98874       {
98875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98876       };
98877     } catch (std::exception& e) {
98878       {
98879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98880       };
98881     } catch (Dali::DaliException e) {
98882       {
98883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98884       };
98885     } catch (...) {
98886       {
98887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98888       };
98889     }
98890   }
98891
98892   jresult = (void *)result;
98893   return jresult;
98894 }
98895
98896
98897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
98898   void * jresult ;
98899   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
98900   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98901
98902   arg1 = (Dali::Toolkit::Ruler *)jarg1;
98903   {
98904     try {
98905       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
98906     } catch (std::out_of_range& e) {
98907       {
98908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98909       };
98910     } catch (std::exception& e) {
98911       {
98912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98913       };
98914     } catch (Dali::DaliException e) {
98915       {
98916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98917       };
98918     } catch (...) {
98919       {
98920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98921       };
98922     }
98923   }
98924
98925   jresult = (void *)result;
98926   return jresult;
98927 }
98928
98929
98930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
98931   void * jresult ;
98932   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
98933   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98934
98935   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98936   if (!arg1) {
98937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98938     return 0;
98939   }
98940   {
98941     try {
98942       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98943     } catch (std::out_of_range& e) {
98944       {
98945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98946       };
98947     } catch (std::exception& e) {
98948       {
98949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98950       };
98951     } catch (Dali::DaliException e) {
98952       {
98953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98954       };
98955     } catch (...) {
98956       {
98957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98958       };
98959     }
98960   }
98961
98962   jresult = (void *)result;
98963   return jresult;
98964 }
98965
98966
98967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98968   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98969
98970   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98971   {
98972     try {
98973       delete arg1;
98974     } catch (std::out_of_range& e) {
98975       {
98976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98977       };
98978     } catch (std::exception& e) {
98979       {
98980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98981       };
98982     } catch (Dali::DaliException e) {
98983       {
98984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98985       };
98986     } catch (...) {
98987       {
98988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98989       };
98990     }
98991   }
98992
98993 }
98994
98995
98996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98997   void * jresult ;
98998   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98999   Dali::Toolkit::Ruler *result = 0 ;
99000
99001   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99002   {
99003     try {
99004       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99005     } catch (std::out_of_range& e) {
99006       {
99007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99008       };
99009     } catch (std::exception& e) {
99010       {
99011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99012       };
99013     } catch (Dali::DaliException e) {
99014       {
99015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99016       };
99017     } catch (...) {
99018       {
99019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99020       };
99021     }
99022   }
99023
99024   jresult = (void *)result;
99025   return jresult;
99026 }
99027
99028
99029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99030   void * jresult ;
99031   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99032   Dali::Toolkit::Ruler *result = 0 ;
99033
99034   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99035   {
99036     try {
99037       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99038     } catch (std::out_of_range& e) {
99039       {
99040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99041       };
99042     } catch (std::exception& e) {
99043       {
99044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99045       };
99046     } catch (Dali::DaliException e) {
99047       {
99048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99049       };
99050     } catch (...) {
99051       {
99052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99053       };
99054     }
99055   }
99056
99057   jresult = (void *)result;
99058   return jresult;
99059 }
99060
99061
99062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99063   void * jresult ;
99064   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99065   Dali::Toolkit::Ruler *result = 0 ;
99066
99067   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99068   {
99069     try {
99070       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99071     } catch (std::out_of_range& e) {
99072       {
99073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99074       };
99075     } catch (std::exception& e) {
99076       {
99077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99078       };
99079     } catch (Dali::DaliException e) {
99080       {
99081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99082       };
99083     } catch (...) {
99084       {
99085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99086       };
99087     }
99088   }
99089
99090   jresult = (void *)result;
99091   return jresult;
99092 }
99093
99094
99095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99096   void * jresult ;
99097   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99098   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99099   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99100
99101   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99102   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99103   if (!arg2) {
99104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99105     return 0;
99106   }
99107   {
99108     try {
99109       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99110     } catch (std::out_of_range& e) {
99111       {
99112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99113       };
99114     } catch (std::exception& e) {
99115       {
99116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99117       };
99118     } catch (Dali::DaliException e) {
99119       {
99120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99121       };
99122     } catch (...) {
99123       {
99124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99125       };
99126     }
99127   }
99128
99129   jresult = (void *)result;
99130   return jresult;
99131 }
99132
99133
99134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99135   void * jresult ;
99136   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99137   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99138   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99139
99140   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99141   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99142   {
99143     try {
99144       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99145     } catch (std::out_of_range& e) {
99146       {
99147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99148       };
99149     } catch (std::exception& e) {
99150       {
99151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99152       };
99153     } catch (Dali::DaliException e) {
99154       {
99155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99156       };
99157     } catch (...) {
99158       {
99159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99160       };
99161     }
99162   }
99163
99164   jresult = (void *)result;
99165   return jresult;
99166 }
99167
99168
99169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99170   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99171
99172   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99173   {
99174     try {
99175       (arg1)->Reset();
99176     } catch (std::out_of_range& e) {
99177       {
99178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99179       };
99180     } catch (std::exception& e) {
99181       {
99182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99183       };
99184     } catch (Dali::DaliException e) {
99185       {
99186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99187       };
99188     } catch (...) {
99189       {
99190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99191       };
99192     }
99193   }
99194
99195 }
99196
99197
99198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99199   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99200   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99201
99202   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99203   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99204   {
99205     try {
99206       (arg1)->Reset(arg2);
99207     } catch (std::out_of_range& e) {
99208       {
99209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99210       };
99211     } catch (std::exception& e) {
99212       {
99213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99214       };
99215     } catch (Dali::DaliException e) {
99216       {
99217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99218       };
99219     } catch (...) {
99220       {
99221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99222       };
99223     }
99224   }
99225
99226 }
99227
99228
99229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99230   void * jresult ;
99231   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99232   Dali::Toolkit::Ruler *result = 0 ;
99233
99234   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99235   {
99236     try {
99237       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99238     } catch (std::out_of_range& e) {
99239       {
99240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99241       };
99242     } catch (std::exception& e) {
99243       {
99244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99245       };
99246     } catch (Dali::DaliException e) {
99247       {
99248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99249       };
99250     } catch (...) {
99251       {
99252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99253       };
99254     }
99255   }
99256
99257   jresult = (void *)result;
99258   return jresult;
99259 }
99260
99261
99262 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99263   float jresult ;
99264   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99265   float arg2 ;
99266   float arg3 ;
99267   float result;
99268
99269   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99270   arg2 = (float)jarg2;
99271   arg3 = (float)jarg3;
99272   {
99273     try {
99274       result = (float)(*arg1)->Snap(arg2,arg3);
99275     } catch (std::out_of_range& e) {
99276       {
99277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99278       };
99279     } catch (std::exception& e) {
99280       {
99281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99282       };
99283     } catch (Dali::DaliException e) {
99284       {
99285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99286       };
99287     } catch (...) {
99288       {
99289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99290       };
99291     }
99292   }
99293
99294   jresult = result;
99295   return jresult;
99296 }
99297
99298
99299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99300   float jresult ;
99301   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99302   float arg2 ;
99303   float result;
99304
99305   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99306   arg2 = (float)jarg2;
99307   {
99308     try {
99309       result = (float)(*arg1)->Snap(arg2);
99310     } catch (std::out_of_range& e) {
99311       {
99312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99313       };
99314     } catch (std::exception& e) {
99315       {
99316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99317       };
99318     } catch (Dali::DaliException e) {
99319       {
99320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99321       };
99322     } catch (...) {
99323       {
99324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99325       };
99326     }
99327   }
99328
99329   jresult = result;
99330   return jresult;
99331 }
99332
99333
99334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99335   float jresult ;
99336   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99337   unsigned int arg2 ;
99338   unsigned int *arg3 = 0 ;
99339   bool arg4 ;
99340   float result;
99341
99342   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99343   arg2 = (unsigned int)jarg2;
99344   arg3 = (unsigned int *)jarg3;
99345   arg4 = jarg4 ? true : false;
99346   {
99347     try {
99348       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99349     } catch (std::out_of_range& e) {
99350       {
99351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99352       };
99353     } catch (std::exception& e) {
99354       {
99355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99356       };
99357     } catch (Dali::DaliException e) {
99358       {
99359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99360       };
99361     } catch (...) {
99362       {
99363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99364       };
99365     }
99366   }
99367
99368   jresult = result;
99369   return jresult;
99370 }
99371
99372
99373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99374   unsigned int jresult ;
99375   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99376   float arg2 ;
99377   bool arg3 ;
99378   unsigned int result;
99379
99380   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99381   arg2 = (float)jarg2;
99382   arg3 = jarg3 ? true : false;
99383   {
99384     try {
99385       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99386     } catch (std::out_of_range& e) {
99387       {
99388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99389       };
99390     } catch (std::exception& e) {
99391       {
99392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99393       };
99394     } catch (Dali::DaliException e) {
99395       {
99396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99397       };
99398     } catch (...) {
99399       {
99400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99401       };
99402     }
99403   }
99404
99405   jresult = result;
99406   return jresult;
99407 }
99408
99409
99410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99411   unsigned int jresult ;
99412   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99413   unsigned int result;
99414
99415   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99416   {
99417     try {
99418       result = (unsigned int)(*arg1)->GetTotalPages();
99419     } catch (std::out_of_range& e) {
99420       {
99421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99422       };
99423     } catch (std::exception& e) {
99424       {
99425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99426       };
99427     } catch (Dali::DaliException e) {
99428       {
99429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99430       };
99431     } catch (...) {
99432       {
99433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99434       };
99435     }
99436   }
99437
99438   jresult = result;
99439   return jresult;
99440 }
99441
99442
99443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99444   int jresult ;
99445   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99446   Dali::Toolkit::Ruler::RulerType result;
99447
99448   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99449   {
99450     try {
99451       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99452     } catch (std::out_of_range& e) {
99453       {
99454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99455       };
99456     } catch (std::exception& e) {
99457       {
99458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99459       };
99460     } catch (Dali::DaliException e) {
99461       {
99462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99463       };
99464     } catch (...) {
99465       {
99466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99467       };
99468     }
99469   }
99470
99471   jresult = (int)result;
99472   return jresult;
99473 }
99474
99475
99476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99477   unsigned int jresult ;
99478   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99479   bool result;
99480
99481   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99482   {
99483     try {
99484       result = (bool)(*arg1)->IsEnabled();
99485     } catch (std::out_of_range& e) {
99486       {
99487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99488       };
99489     } catch (std::exception& e) {
99490       {
99491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99492       };
99493     } catch (Dali::DaliException e) {
99494       {
99495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99496       };
99497     } catch (...) {
99498       {
99499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99500       };
99501     }
99502   }
99503
99504   jresult = result;
99505   return jresult;
99506 }
99507
99508
99509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99510   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99511
99512   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99513   {
99514     try {
99515       (*arg1)->Enable();
99516     } catch (std::out_of_range& e) {
99517       {
99518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99519       };
99520     } catch (std::exception& e) {
99521       {
99522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99523       };
99524     } catch (Dali::DaliException e) {
99525       {
99526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99527       };
99528     } catch (...) {
99529       {
99530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99531       };
99532     }
99533   }
99534
99535 }
99536
99537
99538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99539   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99540
99541   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99542   {
99543     try {
99544       (*arg1)->Disable();
99545     } catch (std::out_of_range& e) {
99546       {
99547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99548       };
99549     } catch (std::exception& e) {
99550       {
99551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99552       };
99553     } catch (Dali::DaliException e) {
99554       {
99555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99556       };
99557     } catch (...) {
99558       {
99559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99560       };
99561     }
99562   }
99563
99564 }
99565
99566
99567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99568   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99569   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99570   Dali::Toolkit::RulerDomain *argp2 ;
99571
99572   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99573   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99574   if (!argp2) {
99575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99576     return ;
99577   }
99578   arg2 = *argp2;
99579   {
99580     try {
99581       (*arg1)->SetDomain(arg2);
99582     } catch (std::out_of_range& e) {
99583       {
99584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99585       };
99586     } catch (std::exception& e) {
99587       {
99588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99589       };
99590     } catch (Dali::DaliException e) {
99591       {
99592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99593       };
99594     } catch (...) {
99595       {
99596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99597       };
99598     }
99599   }
99600
99601 }
99602
99603
99604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99605   void * jresult ;
99606   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99607   Dali::Toolkit::RulerDomain *result = 0 ;
99608
99609   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99610   {
99611     try {
99612       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99613     } catch (std::out_of_range& e) {
99614       {
99615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99616       };
99617     } catch (std::exception& e) {
99618       {
99619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99620       };
99621     } catch (Dali::DaliException e) {
99622       {
99623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99624       };
99625     } catch (...) {
99626       {
99627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99628       };
99629     }
99630   }
99631
99632   jresult = (void *)result;
99633   return jresult;
99634 }
99635
99636
99637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99638   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99639
99640   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99641   {
99642     try {
99643       (*arg1)->DisableDomain();
99644     } catch (std::out_of_range& e) {
99645       {
99646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99647       };
99648     } catch (std::exception& e) {
99649       {
99650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99651       };
99652     } catch (Dali::DaliException e) {
99653       {
99654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99655       };
99656     } catch (...) {
99657       {
99658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99659       };
99660     }
99661   }
99662
99663 }
99664
99665
99666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
99667   float jresult ;
99668   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99669   float arg2 ;
99670   float arg3 ;
99671   float arg4 ;
99672   float result;
99673
99674   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99675   arg2 = (float)jarg2;
99676   arg3 = (float)jarg3;
99677   arg4 = (float)jarg4;
99678   {
99679     try {
99680       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
99681     } catch (std::out_of_range& e) {
99682       {
99683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99684       };
99685     } catch (std::exception& e) {
99686       {
99687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99688       };
99689     } catch (Dali::DaliException e) {
99690       {
99691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99692       };
99693     } catch (...) {
99694       {
99695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99696       };
99697     }
99698   }
99699
99700   jresult = result;
99701   return jresult;
99702 }
99703
99704
99705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
99706   float jresult ;
99707   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99708   float arg2 ;
99709   float arg3 ;
99710   float result;
99711
99712   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99713   arg2 = (float)jarg2;
99714   arg3 = (float)jarg3;
99715   {
99716     try {
99717       result = (float)(*arg1)->Clamp(arg2,arg3);
99718     } catch (std::out_of_range& e) {
99719       {
99720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99721       };
99722     } catch (std::exception& e) {
99723       {
99724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99725       };
99726     } catch (Dali::DaliException e) {
99727       {
99728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99729       };
99730     } catch (...) {
99731       {
99732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99733       };
99734     }
99735   }
99736
99737   jresult = result;
99738   return jresult;
99739 }
99740
99741
99742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
99743   float jresult ;
99744   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99745   float arg2 ;
99746   float result;
99747
99748   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99749   arg2 = (float)jarg2;
99750   {
99751     try {
99752       result = (float)(*arg1)->Clamp(arg2);
99753     } catch (std::out_of_range& e) {
99754       {
99755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99756       };
99757     } catch (std::exception& e) {
99758       {
99759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99760       };
99761     } catch (Dali::DaliException e) {
99762       {
99763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99764       };
99765     } catch (...) {
99766       {
99767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99768       };
99769     }
99770   }
99771
99772   jresult = result;
99773   return jresult;
99774 }
99775
99776
99777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
99778   float jresult ;
99779   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99780   float arg2 ;
99781   float arg3 ;
99782   float arg4 ;
99783   Dali::Toolkit::ClampState *arg5 = 0 ;
99784   float result;
99785
99786   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99787   arg2 = (float)jarg2;
99788   arg3 = (float)jarg3;
99789   arg4 = (float)jarg4;
99790   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99791   if (!arg5) {
99792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99793     return 0;
99794   }
99795   {
99796     try {
99797       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
99798     } catch (std::out_of_range& e) {
99799       {
99800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99801       };
99802     } catch (std::exception& e) {
99803       {
99804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99805       };
99806     } catch (Dali::DaliException e) {
99807       {
99808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99809       };
99810     } catch (...) {
99811       {
99812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99813       };
99814     }
99815   }
99816
99817   jresult = result;
99818   return jresult;
99819 }
99820
99821
99822 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
99823   float jresult ;
99824   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99825   float arg2 ;
99826   float arg3 ;
99827   float arg4 ;
99828   float arg5 ;
99829   float result;
99830
99831   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99832   arg2 = (float)jarg2;
99833   arg3 = (float)jarg3;
99834   arg4 = (float)jarg4;
99835   arg5 = (float)jarg5;
99836   {
99837     try {
99838       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
99839     } catch (std::out_of_range& e) {
99840       {
99841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99842       };
99843     } catch (std::exception& e) {
99844       {
99845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99846       };
99847     } catch (Dali::DaliException e) {
99848       {
99849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99850       };
99851     } catch (...) {
99852       {
99853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99854       };
99855     }
99856   }
99857
99858   jresult = result;
99859   return jresult;
99860 }
99861
99862
99863 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
99864   float jresult ;
99865   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99866   float arg2 ;
99867   float arg3 ;
99868   float arg4 ;
99869   float result;
99870
99871   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99872   arg2 = (float)jarg2;
99873   arg3 = (float)jarg3;
99874   arg4 = (float)jarg4;
99875   {
99876     try {
99877       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
99878     } catch (std::out_of_range& e) {
99879       {
99880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99881       };
99882     } catch (std::exception& e) {
99883       {
99884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99885       };
99886     } catch (Dali::DaliException e) {
99887       {
99888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99889       };
99890     } catch (...) {
99891       {
99892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99893       };
99894     }
99895   }
99896
99897   jresult = result;
99898   return jresult;
99899 }
99900
99901
99902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
99903   float jresult ;
99904   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99905   float arg2 ;
99906   float arg3 ;
99907   float result;
99908
99909   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99910   arg2 = (float)jarg2;
99911   arg3 = (float)jarg3;
99912   {
99913     try {
99914       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
99915     } catch (std::out_of_range& e) {
99916       {
99917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99918       };
99919     } catch (std::exception& e) {
99920       {
99921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99922       };
99923     } catch (Dali::DaliException e) {
99924       {
99925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99926       };
99927     } catch (...) {
99928       {
99929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99930       };
99931     }
99932   }
99933
99934   jresult = result;
99935   return jresult;
99936 }
99937
99938
99939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99940   float jresult ;
99941   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99942   float arg2 ;
99943   float result;
99944
99945   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99946   arg2 = (float)jarg2;
99947   {
99948     try {
99949       result = (float)(*arg1)->SnapAndClamp(arg2);
99950     } catch (std::out_of_range& e) {
99951       {
99952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99953       };
99954     } catch (std::exception& e) {
99955       {
99956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99957       };
99958     } catch (Dali::DaliException e) {
99959       {
99960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99961       };
99962     } catch (...) {
99963       {
99964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99965       };
99966     }
99967   }
99968
99969   jresult = result;
99970   return jresult;
99971 }
99972
99973
99974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99975   float jresult ;
99976   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99977   float arg2 ;
99978   float arg3 ;
99979   float arg4 ;
99980   float arg5 ;
99981   Dali::Toolkit::ClampState *arg6 = 0 ;
99982   float result;
99983
99984   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99985   arg2 = (float)jarg2;
99986   arg3 = (float)jarg3;
99987   arg4 = (float)jarg4;
99988   arg5 = (float)jarg5;
99989   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99990   if (!arg6) {
99991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99992     return 0;
99993   }
99994   {
99995     try {
99996       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99997     } catch (std::out_of_range& e) {
99998       {
99999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100000       };
100001     } catch (std::exception& e) {
100002       {
100003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100004       };
100005     } catch (Dali::DaliException e) {
100006       {
100007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100008       };
100009     } catch (...) {
100010       {
100011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100012       };
100013     }
100014   }
100015
100016   jresult = result;
100017   return jresult;
100018 }
100019
100020
100021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100022   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100023
100024   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100025   {
100026     try {
100027       (*arg1)->Reference();
100028     } catch (std::out_of_range& e) {
100029       {
100030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100031       };
100032     } catch (std::exception& e) {
100033       {
100034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100035       };
100036     } catch (Dali::DaliException e) {
100037       {
100038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100039       };
100040     } catch (...) {
100041       {
100042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100043       };
100044     }
100045   }
100046
100047 }
100048
100049
100050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100051   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100052
100053   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100054   {
100055     try {
100056       (*arg1)->Unreference();
100057     } catch (std::out_of_range& e) {
100058       {
100059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100060       };
100061     } catch (std::exception& e) {
100062       {
100063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100064       };
100065     } catch (Dali::DaliException e) {
100066       {
100067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100068       };
100069     } catch (...) {
100070       {
100071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100072       };
100073     }
100074   }
100075
100076 }
100077
100078
100079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100080   int jresult ;
100081   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100082   int result;
100083
100084   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100085   {
100086     try {
100087       result = (int)(*arg1)->ReferenceCount();
100088     } catch (std::out_of_range& e) {
100089       {
100090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100091       };
100092     } catch (std::exception& e) {
100093       {
100094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100095       };
100096     } catch (Dali::DaliException e) {
100097       {
100098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100099       };
100100     } catch (...) {
100101       {
100102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100103       };
100104     }
100105   }
100106
100107   jresult = result;
100108   return jresult;
100109 }
100110
100111
100112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100113   unsigned int jresult ;
100114   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100115   bool result;
100116
100117   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100118   {
100119     try {
100120       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100121     } catch (std::out_of_range& e) {
100122       {
100123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100124       };
100125     } catch (std::exception& e) {
100126       {
100127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100128       };
100129     } catch (Dali::DaliException e) {
100130       {
100131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100132       };
100133     } catch (...) {
100134       {
100135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100136       };
100137     }
100138   }
100139
100140   jresult = result;
100141   return jresult;
100142 }
100143
100144
100145 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100146   unsigned long jresult ;
100147   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100148   std::size_t result;
100149
100150   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100151   {
100152     try {
100153       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100154     } catch (std::out_of_range& e) {
100155       {
100156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100157       };
100158     } catch (std::exception& e) {
100159       {
100160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100161       };
100162     } catch (Dali::DaliException e) {
100163       {
100164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100165       };
100166     } catch (...) {
100167       {
100168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100169       };
100170     }
100171   }
100172
100173   jresult = (unsigned long)result;
100174   return jresult;
100175 }
100176
100177
100178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100179   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100180   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100181
100182   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100183   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100184   {
100185     try {
100186       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
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 (Dali::DaliException e) {
100196       {
100197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100198       };
100199     } catch (...) {
100200       {
100201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100202       };
100203     }
100204   }
100205
100206 }
100207
100208
100209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100210   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100211   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100212
100213   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100214   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100215   {
100216     try {
100217       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100218     } catch (std::out_of_range& e) {
100219       {
100220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100221       };
100222     } catch (std::exception& e) {
100223       {
100224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100225       };
100226     } catch (Dali::DaliException e) {
100227       {
100228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100229       };
100230     } catch (...) {
100231       {
100232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100233       };
100234     }
100235   }
100236
100237 }
100238
100239
100240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100241   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100242   Dali::Toolkit::Control arg2 ;
100243   Dali::Toolkit::Control *argp2 ;
100244
100245   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100246   argp2 = (Dali::Toolkit::Control *)jarg2;
100247   if (!argp2) {
100248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100249     return ;
100250   }
100251   arg2 = *argp2;
100252   {
100253     try {
100254       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100255     } catch (std::out_of_range& e) {
100256       {
100257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100258       };
100259     } catch (std::exception& e) {
100260       {
100261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100262       };
100263     } catch (Dali::DaliException e) {
100264       {
100265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100266       };
100267     } catch (...) {
100268       {
100269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100270       };
100271     }
100272   }
100273
100274 }
100275
100276
100277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100278   void * jresult ;
100279   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100280
100281   {
100282     try {
100283       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100284     } catch (std::out_of_range& e) {
100285       {
100286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100287       };
100288     } catch (std::exception& e) {
100289       {
100290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100291       };
100292     } catch (Dali::DaliException e) {
100293       {
100294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100295       };
100296     } catch (...) {
100297       {
100298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100299       };
100300     }
100301   }
100302
100303   jresult = (void *)result;
100304   return jresult;
100305 }
100306
100307
100308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100309   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100310
100311   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100312   {
100313     try {
100314       delete arg1;
100315     } catch (std::out_of_range& e) {
100316       {
100317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100318       };
100319     } catch (std::exception& e) {
100320       {
100321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100322       };
100323     } catch (Dali::DaliException e) {
100324       {
100325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100326       };
100327     } catch (...) {
100328       {
100329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100330       };
100331     }
100332   }
100333
100334 }
100335
100336 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100337   Dali::RefObject *result = NULL;
100338
100339   if (arg1)
100340   {
100341     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100342   }
100343   return result;
100344 }
100345
100346 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100347     return (Dali::RefObject *)jarg1;
100348 }
100349
100350 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100351     return (Dali::SignalObserver *)jarg1;
100352 }
100353
100354 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100355     return (Dali::ConnectionTrackerInterface *)jarg1;
100356 }
100357
100358 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100359     return (Dali::BaseHandle *)jarg1;
100360 }
100361
100362 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100363     return (Dali::BaseHandle *)jarg1;
100364 }
100365
100366 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100367     return (Dali::BaseHandle *)jarg1;
100368 }
100369
100370 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100371     return (Dali::BaseHandle *)jarg1;
100372 }
100373
100374 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100375     return (Dali::BaseHandle *)jarg1;
100376 }
100377
100378 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100379     return (Dali::BaseHandle *)jarg1;
100380 }
100381
100382 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100383     return (Dali::BaseHandle *)jarg1;
100384 }
100385
100386 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100387     return (Dali::BaseHandle *)jarg1;
100388 }
100389
100390 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100391     return (Dali::BaseHandle *)jarg1;
100392 }
100393
100394 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100395     return (Dali::BaseHandle *)jarg1;
100396 }
100397
100398 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100399     return (Dali::BaseHandle *)jarg1;
100400 }
100401
100402 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100403     return (Dali::BaseHandle *)jarg1;
100404 }
100405
100406 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100407     return (Dali::BaseHandle *)jarg1;
100408 }
100409
100410 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100411     return (Dali::Handle *)jarg1;
100412 }
100413
100414 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100415     return (Dali::Handle *)jarg1;
100416 }
100417
100418 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100419     return (Dali::BaseHandle *)jarg1;
100420 }
100421
100422 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100423     return (Dali::BaseHandle *)jarg1;
100424 }
100425
100426 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100427     return (Dali::Handle *)jarg1;
100428 }
100429
100430 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100431     return (Dali::BaseHandle *)jarg1;
100432 }
100433
100434 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100435     return (Dali::Handle *)jarg1;
100436 }
100437
100438 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100439     return (Dali::GestureDetector *)jarg1;
100440 }
100441
100442 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100443     return (Dali::Gesture *)jarg1;
100444 }
100445
100446 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100447     return (Dali::Handle *)jarg1;
100448 }
100449
100450 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100451     return (Dali::Actor *)jarg1;
100452 }
100453
100454 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100455     return (Dali::BaseHandle *)jarg1;
100456 }
100457
100458 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100459     return (Dali::RefObject *)jarg1;
100460 }
100461
100462 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100463     return (Dali::Actor *)jarg1;
100464 }
100465
100466 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100467     return (Dali::GestureDetector *)jarg1;
100468 }
100469
100470 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100471     return (Dali::Gesture *)jarg1;
100472 }
100473
100474 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100475     return (Dali::GestureDetector *)jarg1;
100476 }
100477
100478 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100479     return (Dali::Gesture *)jarg1;
100480 }
100481
100482 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100483     return (Dali::GestureDetector *)jarg1;
100484 }
100485
100486 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100487     return (Dali::Gesture *)jarg1;
100488 }
100489
100490 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100491     return (Dali::BaseHandle *)jarg1;
100492 }
100493
100494 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100495     return (Dali::Handle *)jarg1;
100496 }
100497
100498 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100499     return (Dali::Handle *)jarg1;
100500 }
100501
100502 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100503     return (Dali::Handle *)jarg1;
100504 }
100505
100506 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100507     return (Dali::Image *)jarg1;
100508 }
100509
100510 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100511     return (Dali::Image *)jarg1;
100512 }
100513
100514 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100515     return (Dali::Image *)jarg1;
100516 }
100517
100518 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100519     return (Dali::RefObject *)jarg1;
100520 }
100521
100522 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100523     return (Dali::Image *)jarg1;
100524 }
100525
100526 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100527     return (Dali::Image *)jarg1;
100528 }
100529
100530 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100531     return (Dali::ResourceImage *)jarg1;
100532 }
100533
100534 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100535     return (Dali::Actor *)jarg1;
100536 }
100537
100538 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100539     return (Dali::BaseHandle *)jarg1;
100540 }
100541
100542 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100543     return (Dali::BaseHandle *)jarg1;
100544 }
100545
100546 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100547     return (Dali::BaseHandle *)jarg1;
100548 }
100549
100550 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100551     return (Dali::CustomActorImpl *)jarg1;
100552 }
100553
100554 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100555     return (Dali::CustomActor *)jarg1;
100556 }
100557
100558 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100559     return (Dali::BaseHandle *)jarg1;
100560 }
100561
100562 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100563     return (Dali::Toolkit::Control *)jarg1;
100564 }
100565
100566 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100567     return (Dali::Toolkit::Control *)jarg1;
100568 }
100569
100570 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100571     return (Dali::Toolkit::Button *)jarg1;
100572 }
100573
100574 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100575     return (Dali::Toolkit::Button *)jarg1;
100576 }
100577
100578 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100579     return (Dali::Toolkit::Button *)jarg1;
100580 }
100581
100582 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100583     return (Dali::Toolkit::Control *)jarg1;
100584 }
100585
100586 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100587     return (Dali::Toolkit::Control *)jarg1;
100588 }
100589
100590 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100591     return (Dali::Toolkit::Control *)jarg1;
100592 }
100593
100594 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100595     return (Dali::Toolkit::Control *)jarg1;
100596 }
100597
100598 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100599     return (Dali::Toolkit::Control *)jarg1;
100600 }
100601
100602 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100603     return (Dali::RefObject *)jarg1;
100604 }
100605
100606 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100607     return (Dali::Toolkit::Scrollable *)jarg1;
100608 }
100609
100610 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100611     return (Dali::BaseHandle *)jarg1;
100612 }
100613
100614 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100615     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100616 }
100617
100618 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100619     return (Dali::RefObject *)jarg1;
100620 }
100621
100622 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100623     return (Dali::Toolkit::Ruler *)jarg1;
100624 }
100625
100626 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100627     return (Dali::Toolkit::Ruler *)jarg1;
100628 }
100629
100630 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100631     return (Dali::Toolkit::Scrollable *)jarg1;
100632 }
100633
100634 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100635     return (Dali::Toolkit::Control *)jarg1;
100636 }
100637
100638
100639 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100640     return (Dali::Toolkit::Control *)jarg1;
100641 }
100642
100643 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
100644     return (Dali::BaseHandle *)jarg1;
100645 }
100646
100647 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
100648     return (Dali::BaseHandle *)jarg1;
100649 }
100650
100651 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
100652     return (Dali::Toolkit::Control *)jarg1;
100653 }
100654
100655 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
100656     return (Dali::Toolkit::Control *)jarg1;
100657 }
100658
100659 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
100660     return (Dali::Toolkit::Control *)jarg1;
100661 }
100662
100663 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
100664     return (Dali::Toolkit::Control *)jarg1;
100665 }
100666
100667 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
100668     return (Dali::Toolkit::Control *)jarg1;
100669 }
100670
100671 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
100672     return (Dali::Toolkit::Control *)jarg1;
100673 }
100674
100675 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
100676     return (Dali::Toolkit::PageTurnView *)jarg1;
100677 }
100678
100679 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
100680     return (Dali::Toolkit::PageTurnView *)jarg1;
100681 }
100682
100683 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
100684     return (Dali::Toolkit::Button *)jarg1;
100685 }
100686
100687 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
100688     return (Dali::BaseHandle *)jarg1;
100689 }
100690
100691 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
100692     return (Dali::BaseHandle *)jarg1;
100693 }
100694
100695 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
100696     return (Dali::BaseHandle *)jarg1;
100697 }
100698
100699 /*
100700  * Widget binding
100701  */
100702 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
100703     return (Dali::BaseHandle *)jarg1;
100704 }
100705
100706 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
100707     return (Dali::BaseObject *)jarg1;
100708 }
100709
100710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
100711   void * jresult ;
100712   Dali::Widget result;
100713
100714   {
100715     try {
100716       result = Dali::Widget::New();
100717     } catch (std::out_of_range& e) {
100718       {
100719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100720       };
100721     } catch (std::exception& e) {
100722       {
100723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100724       };
100725     } catch (...) {
100726       {
100727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100728       };
100729     }
100730   }
100731   jresult = new Dali::Widget((const Dali::Widget &)result);
100732   return jresult;
100733 }
100734
100735
100736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
100737   void * jresult ;
100738   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
100739   Dali::Widget result;
100740
100741   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100742
100743   if (!arg1) {
100744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
100745     return 0;
100746   }
100747   {
100748     try {
100749       jresult = new Dali::Widget(arg1);
100750     } catch (std::out_of_range& e) {
100751       {
100752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100753       };
100754     } catch (std::exception& e) {
100755       {
100756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100757       };
100758     } catch (...) {
100759       {
100760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100761       };
100762     }
100763   }
100764   return jresult;
100765 }
100766
100767
100768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
100769   void * jresult ;
100770   Dali::Widget *result = 0 ;
100771
100772   {
100773     try {
100774       result = (Dali::Widget *)new Dali::Widget();
100775     } catch (std::out_of_range& e) {
100776       {
100777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100778       };
100779     } catch (std::exception& e) {
100780       {
100781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100782       };
100783     } catch (...) {
100784       {
100785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100786       };
100787     }
100788   }
100789   jresult = (void *)result;
100790   return jresult;
100791 }
100792
100793
100794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
100795   void * jresult ;
100796   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100797   Dali::Widget *arg2 = 0 ;
100798   Dali::Widget *result = 0 ;
100799
100800   arg1 = (Dali::Widget *)jarg1;
100801   arg2 = (Dali::Widget *)jarg2;
100802   if (!arg2) {
100803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
100804     return 0;
100805   }
100806   {
100807     try {
100808       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
100809     } catch (std::out_of_range& e) {
100810       {
100811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100812       };
100813     } catch (std::exception& e) {
100814       {
100815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100816       };
100817     } catch (...) {
100818       {
100819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100820       };
100821     }
100822   }
100823   jresult = (void *)result;
100824   return jresult;
100825 }
100826
100827
100828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
100829   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100830
100831   arg1 = (Dali::Widget *)jarg1;
100832   {
100833     try {
100834       delete arg1;
100835     } catch (std::out_of_range& e) {
100836       {
100837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100838       };
100839     } catch (std::exception& e) {
100840       {
100841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100842       };
100843     } catch (...) {
100844       {
100845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100846       };
100847     }
100848   }
100849 }
100850
100851
100852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
100853   void * jresult ;
100854   SwigDirector_WidgetImpl* result;
100855   {
100856     try {
100857       result = new SwigDirector_WidgetImpl();
100858     } catch (std::out_of_range& e) {
100859       {
100860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100861       };
100862     } catch (std::exception& e) {
100863       {
100864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100865       };
100866     } catch (...) {
100867       {
100868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100869       };
100870     }
100871   }
100872   jresult = result;
100873   return jresult;
100874 }
100875
100876
100877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
100878   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100879   std::string *arg2 = 0 ;
100880   Dali::Window arg3 ;
100881   Dali::Window *argp3 ;
100882
100883   arg1 = (Dali::Internal::Adaptor::Widget *)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   argp3 = (Dali::Window *)jarg3;
100891   if (!argp3) {
100892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100893     return ;
100894   }
100895   arg3 = *argp3;
100896   {
100897     try {
100898       (arg1)->OnCreate((std::string const &)*arg2,arg3);
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
100915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
100916   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100917   std::string *arg2 = 0 ;
100918   Dali::Window arg3 ;
100919   Dali::Window *argp3 ;
100920
100921   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100922   if (!jarg2) {
100923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100924     return ;
100925   }
100926   std::string arg2_str(jarg2);
100927   arg2 = &arg2_str;
100928   argp3 = (Dali::Window *)jarg3;
100929   if (!argp3) {
100930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100931     return ;
100932   }
100933   arg3 = *argp3;
100934   {
100935     try {
100936       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100937     } catch (std::out_of_range& e) {
100938       {
100939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100940       };
100941     } catch (std::exception& e) {
100942       {
100943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100944       };
100945     } catch (...) {
100946       {
100947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100948       };
100949     }
100950   }
100951 }
100952
100953
100954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100955   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100956   std::string *arg2 = 0 ;
100957   Dali::Widget::Termination arg3 ;
100958
100959   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100960   if (!jarg2) {
100961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100962     return ;
100963   }
100964   std::string arg2_str(jarg2);
100965   arg2 = &arg2_str;
100966   arg3 = (Dali::Widget::Termination)jarg3;
100967   {
100968     try {
100969       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100970     } catch (std::out_of_range& e) {
100971       {
100972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100973       };
100974     } catch (std::exception& e) {
100975       {
100976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100977       };
100978     } catch (...) {
100979       {
100980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100981       };
100982     }
100983   }
100984 }
100985
100986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100987   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100988   std::string *arg2 = 0 ;
100989   Dali::Widget::Termination arg3 ;
100990
100991   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100992   if (!jarg2) {
100993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100994     return ;
100995   }
100996   std::string arg2_str(jarg2);
100997   arg2 = &arg2_str;
100998   arg3 = (Dali::Widget::Termination)jarg3;
100999   {
101000     try {
101001       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101002     } catch (std::out_of_range& e) {
101003       {
101004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101005       };
101006     } catch (std::exception& e) {
101007       {
101008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101009       };
101010     } catch (...) {
101011       {
101012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101013       };
101014     }
101015   }
101016 }
101017
101018
101019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101020   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101021
101022   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101023   {
101024     try {
101025       (arg1)->OnPause();
101026     } catch (std::out_of_range& e) {
101027       {
101028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101029       };
101030     } catch (std::exception& e) {
101031       {
101032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101033       };
101034     } catch (...) {
101035       {
101036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101037       };
101038     }
101039   }
101040 }
101041
101042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101043   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101044
101045   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101046   {
101047     try {
101048       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101049     } catch (std::out_of_range& e) {
101050       {
101051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101052       };
101053     } catch (std::exception& e) {
101054       {
101055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101056       };
101057     } catch (...) {
101058       {
101059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101060       };
101061     }
101062   }
101063 }
101064
101065
101066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101067   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101068
101069   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101070   {
101071     try {
101072       (arg1)->OnResume();
101073     } catch (std::out_of_range& e) {
101074       {
101075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101076       };
101077     } catch (std::exception& e) {
101078       {
101079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101080       };
101081     } catch (...) {
101082       {
101083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101084       };
101085     }
101086   }
101087 }
101088
101089
101090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101091   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101092
101093   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101094   {
101095     try {
101096       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101097     } catch (std::out_of_range& e) {
101098       {
101099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101100       };
101101     } catch (std::exception& e) {
101102       {
101103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101104       };
101105     } catch (...) {
101106       {
101107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101108       };
101109     }
101110   }
101111 }
101112
101113
101114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101115   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101116   Dali::Window arg2 ;
101117   Dali::Window *argp2 ;
101118
101119   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101120   argp2 = (Dali::Window *)jarg2;
101121   if (!argp2) {
101122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101123     return ;
101124   }
101125   arg2 = *argp2;
101126   {
101127     try {
101128       (arg1)->OnResize(arg2);
101129     } catch (std::out_of_range& e) {
101130       {
101131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101132       };
101133     } catch (std::exception& e) {
101134       {
101135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101136       };
101137     } catch (...) {
101138       {
101139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101140       };
101141     }
101142   }
101143 }
101144
101145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101146   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101147   Dali::Window arg2 ;
101148   Dali::Window *argp2 ;
101149
101150   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101151   argp2 = (Dali::Window *)jarg2;
101152   if (!argp2) {
101153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101154     return ;
101155   }
101156   arg2 = *argp2;
101157   {
101158     try {
101159       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101160     } catch (std::out_of_range& e) {
101161       {
101162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101163       };
101164     } catch (std::exception& e) {
101165       {
101166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101167       };
101168     } catch (...) {
101169       {
101170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101171       };
101172     }
101173   }
101174 }
101175
101176
101177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101178   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101179   std::string *arg2 = 0 ;
101180   int arg3 ;
101181
101182   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101183   if (!jarg2) {
101184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101185     return ;
101186   }
101187   std::string arg2_str(jarg2);
101188   arg2 = &arg2_str;
101189   arg3 = (int)jarg3;
101190   {
101191     try {
101192       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101193     } catch (std::out_of_range& e) {
101194       {
101195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101196       };
101197     } catch (std::exception& e) {
101198       {
101199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101200       };
101201     } catch (...) {
101202       {
101203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101204       };
101205     }
101206   }
101207 }
101208
101209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101210   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101211   std::string *arg2 = 0 ;
101212   int arg3 ;
101213
101214   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101215   if (!jarg2) {
101216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101217     return ;
101218   }
101219   std::string arg2_str(jarg2);
101220   arg2 = &arg2_str;
101221   arg3 = (int)jarg3;
101222   {
101223     try {
101224       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101225     } catch (std::out_of_range& e) {
101226       {
101227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101228       };
101229     } catch (std::exception& e) {
101230       {
101231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101232       };
101233     } catch (...) {
101234       {
101235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101236       };
101237     }
101238   }
101239 }
101240
101241
101242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101243   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101244   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101245   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101246
101247   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101248   arg2 = (Dali::SlotObserver *)jarg2;
101249   arg3 = (Dali::CallbackBase *)jarg3;
101250   {
101251     try {
101252       (arg1)->SignalConnected(arg2,arg3);
101253     } catch (std::out_of_range& e) {
101254       {
101255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101256       };
101257     } catch (std::exception& e) {
101258       {
101259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101260       };
101261     } catch (...) {
101262       {
101263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101264       };
101265     }
101266   }
101267 }
101268
101269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101270   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101271   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101272   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101273
101274   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101275   arg2 = (Dali::SlotObserver *)jarg2;
101276   arg3 = (Dali::CallbackBase *)jarg3;
101277   {
101278     try {
101279       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101280     } catch (std::out_of_range& e) {
101281       {
101282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101283       };
101284     } catch (std::exception& e) {
101285       {
101286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101287       };
101288     } catch (...) {
101289       {
101290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101291       };
101292     }
101293   }
101294 }
101295
101296
101297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101298   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101299   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101300   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101301
101302   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101303   arg2 = (Dali::SlotObserver *)jarg2;
101304   arg3 = (Dali::CallbackBase *)jarg3;
101305   {
101306     try {
101307       (arg1)->SignalDisconnected(arg2,arg3);
101308     } catch (std::out_of_range& e) {
101309       {
101310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101311       };
101312     } catch (std::exception& e) {
101313       {
101314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101315       };
101316     } catch (...) {
101317       {
101318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101319       };
101320     }
101321   }
101322 }
101323
101324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101325   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101326   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101327   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101328
101329   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101330   arg2 = (Dali::SlotObserver *)jarg2;
101331   arg3 = (Dali::CallbackBase *)jarg3;
101332   {
101333     try {
101334       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101335     } catch (std::out_of_range& e) {
101336       {
101337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101338       };
101339     } catch (std::exception& e) {
101340       {
101341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101342       };
101343     } catch (...) {
101344       {
101345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101346       };
101347     }
101348   }
101349 }
101350
101351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101352   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101353   std::string *arg2 = 0 ;
101354
101355   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101356   if (!jarg2) {
101357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101358     return ;
101359   }
101360   std::string arg2_str(jarg2);
101361   arg2 = &arg2_str;
101362   {
101363     try {
101364       (arg1)->SetContentInfo((std::string const &)*arg2);
101365     } catch (std::out_of_range& e) {
101366       {
101367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101368       };
101369     } catch (std::exception& e) {
101370       {
101371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101372       };
101373     } catch (...) {
101374       {
101375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101376       };
101377     }
101378   }
101379 }
101380
101381
101382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
101383   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101384   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
101385
101386   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101387   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
101388   {
101389     try {
101390       (arg1)->SetImpl(arg2);
101391     } catch (std::out_of_range& e) {
101392       {
101393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101394       };
101395     } catch (std::exception& e) {
101396       {
101397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101398       };
101399     } catch (...) {
101400       {
101401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101402       };
101403     }
101404   }
101405 }
101406
101407 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) {
101408
101409   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
101410   if (director) {
101411     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
101412   }
101413 }
101414
101415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
101416   void * jresult ;
101417   Dali::Widget *arg1 = 0 ;
101418   SwigDirector_WidgetImpl *result = 0 ;
101419
101420   arg1 = (Dali::Widget *)jarg1;
101421   if (!arg1) {
101422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
101423     return 0;
101424   }
101425   {
101426     try {
101427       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
101428     } catch (std::out_of_range& e) {
101429       {
101430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101431       };
101432     } catch (std::exception& e) {
101433       {
101434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101435       };
101436     } catch (...) {
101437       {
101438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101439       };
101440     }
101441   }
101442
101443   jresult = (void *)result;
101444   return jresult;
101445 }
101446
101447
101448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
101449   void * jresult ;
101450   int *arg1 = (int *) 0 ;
101451   char ***arg2 ;
101452   std::string *arg3 = 0 ;
101453   Dali::WidgetApplication result;
101454   {
101455     int index = 0;
101456     int length = 0;
101457     char *retPtr;
101458     char *nextPtr;
101459     argWidgetC = jarg1;
101460     argWidgetV = new char*[jarg1 + 1];
101461
101462     retPtr = strtok_r( jarg2, " ", &nextPtr);
101463     if( retPtr )
101464     {
101465       length = strlen(retPtr);
101466     }
101467     argWidgetV[index] = new char[length + 1];
101468     if( retPtr )
101469     {
101470       strncpy(argWidgetV[index], retPtr, length);
101471     }
101472     argWidgetV[index][length] = '\0';
101473     index++;
101474
101475     while (index < jarg1)
101476     {
101477       length = 0;
101478       retPtr = strtok_r(NULL, " ", &nextPtr);
101479       if( retPtr )
101480       {
101481         length = strlen(retPtr);
101482       }
101483       argWidgetV[index] = new char[length + 1];
101484       if( retPtr )
101485       {
101486         strncpy(argWidgetV[index], retPtr, length);
101487       }
101488       argWidgetV[index][length] = '\0';
101489       index++;
101490     }
101491
101492     argWidgetV[jarg1] = NULL;
101493     argWidgetC = jarg1;
101494
101495     arg1 = &argWidgetC;
101496     arg2 = &argWidgetV;
101497   }
101498
101499   if (!jarg3) {
101500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101501     return 0;
101502   }
101503   std::string arg3_str(jarg3);
101504   arg3 = &arg3_str;
101505   {
101506     try {
101507       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
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::WidgetApplication((const Dali::WidgetApplication &)result);
101523
101524   return jresult;
101525 }
101526
101527
101528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
101529   void * jresult ;
101530   Dali::WidgetApplication *result = 0 ;
101531
101532   {
101533     try {
101534       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
101535     } catch (std::out_of_range& e) {
101536       {
101537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101538       };
101539     } catch (std::exception& e) {
101540       {
101541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101542       };
101543     } catch (...) {
101544       {
101545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101546       };
101547     }
101548   }
101549   jresult = (void *)result;
101550   return jresult;
101551 }
101552
101553
101554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
101555   void * jresult ;
101556   Dali::WidgetApplication *arg1 = 0 ;
101557   Dali::WidgetApplication *result = 0 ;
101558
101559   arg1 = (Dali::WidgetApplication *)jarg1;
101560   if (!arg1) {
101561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101562     return 0;
101563   }
101564   {
101565     try {
101566       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
101567     } catch (std::out_of_range& e) {
101568       {
101569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101570       };
101571     } catch (std::exception& e) {
101572       {
101573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101574       };
101575     } catch (...) {
101576       {
101577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101578       };
101579     }
101580   }
101581   jresult = (void *)result;
101582   return jresult;
101583 }
101584
101585
101586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
101587   void * jresult ;
101588   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101589   Dali::WidgetApplication *arg2 = 0 ;
101590   Dali::WidgetApplication *result = 0 ;
101591
101592   arg1 = (Dali::WidgetApplication *)jarg1;
101593   arg2 = (Dali::WidgetApplication *)jarg2;
101594   if (!arg2) {
101595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101596     return 0;
101597   }
101598   {
101599     try {
101600       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
101601     } catch (std::out_of_range& e) {
101602       {
101603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101604       };
101605     } catch (std::exception& e) {
101606       {
101607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101608       };
101609     } catch (...) {
101610       {
101611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101612       };
101613     }
101614   }
101615   jresult = (void *)result;
101616   return jresult;
101617 }
101618
101619
101620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
101621   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101622
101623   arg1 = (Dali::WidgetApplication *)jarg1;
101624   {
101625     try {
101626       delete arg1;
101627       if( argWidgetV )
101628       {
101629         // free string data
101630         for( int i=0; i < argWidgetC+1; i++)
101631         {
101632           delete [] argWidgetV[i];
101633         }
101634         delete [] argWidgetV;
101635       }
101636     } catch (std::out_of_range& e) {
101637       {
101638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101639       };
101640     } catch (std::exception& e) {
101641       {
101642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101643       };
101644     } catch (...) {
101645       {
101646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101647       };
101648     }
101649   }
101650 }
101651
101652
101653 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
101654 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
101655
101656 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
101657 {
101658   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
101659   return *widget;
101660 }
101661
101662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
101663   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101664   std::string *arg2 = 0 ;
101665
101666   arg1 = (Dali::WidgetApplication *)jarg1;
101667   if (!jarg2) {
101668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101669     return ;
101670   }
101671   std::string arg2_str(*jarg2);
101672   arg2 = &arg2_str;
101673
101674   if(!_CSharpCreateWidgetFunction)
101675   {
101676     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
101677   }
101678
101679   {
101680     try {
101681       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
101682     } catch (std::out_of_range& e) {
101683       {
101684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101685       };
101686     } catch (std::exception& e) {
101687       {
101688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101689       };
101690     } catch (...) {
101691       {
101692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101693       };
101694     }
101695   }
101696
101697   //Typemap argout in c++ file.
101698   //This will convert c++ string to c# string
101699   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
101700 }
101701
101702
101703 //for PixelBuffer and ImageLoading
101704
101705 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
101706     return (Dali::BaseHandle *)jarg1;
101707 }
101708
101709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
101710   void * jresult ;
101711   unsigned int arg1 ;
101712   unsigned int arg2 ;
101713   Dali::Pixel::Format arg3 ;
101714   Dali::Devel::PixelBuffer result;
101715
101716   arg1 = (unsigned int)jarg1;
101717   arg2 = (unsigned int)jarg2;
101718   arg3 = (Dali::Pixel::Format)jarg3;
101719   {
101720     try {
101721       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
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::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101737   return jresult;
101738 }
101739
101740
101741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
101742   void * jresult ;
101743   Dali::Devel::PixelBuffer *result = 0 ;
101744
101745   {
101746     try {
101747       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101748     } catch (std::out_of_range& e) {
101749       {
101750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101751       };
101752     } catch (std::exception& e) {
101753       {
101754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101755       };
101756     } catch (...) {
101757       {
101758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101759       };
101760     }
101761   }
101762   jresult = (void *)result;
101763   return jresult;
101764 }
101765
101766
101767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101768   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101769
101770   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101771   {
101772     try {
101773       delete arg1;
101774     } catch (std::out_of_range& e) {
101775       {
101776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101777       };
101778     } catch (std::exception& e) {
101779       {
101780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101781       };
101782     } catch (...) {
101783       {
101784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101785       };
101786     }
101787   }
101788 }
101789
101790
101791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101792   void * jresult ;
101793   Dali::Devel::PixelBuffer *arg1 = 0 ;
101794   Dali::Devel::PixelBuffer *result = 0 ;
101795
101796   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101797   if (!arg1) {
101798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101799     return 0;
101800   }
101801   {
101802     try {
101803       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101804     } catch (std::out_of_range& e) {
101805       {
101806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101807       };
101808     } catch (std::exception& e) {
101809       {
101810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101811       };
101812     } catch (...) {
101813       {
101814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101815       };
101816     }
101817   }
101818   jresult = (void *)result;
101819   return jresult;
101820 }
101821
101822
101823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101824   void * jresult ;
101825   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101826   Dali::Devel::PixelBuffer *arg2 = 0 ;
101827   Dali::Devel::PixelBuffer *result = 0 ;
101828
101829   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101830   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101831   if (!arg2) {
101832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101833     return 0;
101834   }
101835   {
101836     try {
101837       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101838     } catch (std::out_of_range& e) {
101839       {
101840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101841       };
101842     } catch (std::exception& e) {
101843       {
101844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101845       };
101846     } catch (...) {
101847       {
101848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101849       };
101850     }
101851   }
101852   jresult = (void *)result;
101853   return jresult;
101854 }
101855
101856
101857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101858   void * jresult ;
101859   Dali::Devel::PixelBuffer *arg1 = 0 ;
101860   Dali::PixelData result;
101861
101862   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101863   if (!arg1) {
101864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101865     return 0;
101866   }
101867   {
101868     try {
101869       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101870     } catch (std::out_of_range& e) {
101871       {
101872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101873       };
101874     } catch (std::exception& e) {
101875       {
101876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101877       };
101878     } catch (...) {
101879       {
101880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101881       };
101882     }
101883   }
101884   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101885   return jresult;
101886 }
101887
101888
101889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101890   void * jresult ;
101891   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101892   Dali::PixelData result;
101893
101894   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101895   {
101896     try {
101897       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101898     } catch (std::out_of_range& e) {
101899       {
101900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101901       };
101902     } catch (std::exception& e) {
101903       {
101904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101905       };
101906     } catch (...) {
101907       {
101908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101909       };
101910     }
101911   }
101912   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101913   return jresult;
101914 }
101915
101916
101917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101918   void * jresult ;
101919   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101920   unsigned char *result = 0 ;
101921
101922   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101923   {
101924     try {
101925       result = (unsigned char *)(arg1)->GetBuffer();
101926     } catch (std::out_of_range& e) {
101927       {
101928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101929       };
101930     } catch (std::exception& e) {
101931       {
101932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101933       };
101934     } catch (...) {
101935       {
101936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101937       };
101938     }
101939   }
101940   jresult = (void *)result;
101941   return jresult;
101942 }
101943
101944
101945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101946   unsigned int jresult ;
101947   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101948   unsigned int result;
101949
101950   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101951   {
101952     try {
101953       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101954     } catch (std::out_of_range& e) {
101955       {
101956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101957       };
101958     } catch (std::exception& e) {
101959       {
101960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101961       };
101962     } catch (...) {
101963       {
101964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101965       };
101966     }
101967   }
101968   jresult = result;
101969   return jresult;
101970 }
101971
101972
101973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101974   unsigned int jresult ;
101975   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101976   unsigned int result;
101977
101978   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101979   {
101980     try {
101981       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101982     } catch (std::out_of_range& e) {
101983       {
101984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101985       };
101986     } catch (std::exception& e) {
101987       {
101988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101989       };
101990     } catch (...) {
101991       {
101992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101993       };
101994     }
101995   }
101996   jresult = result;
101997   return jresult;
101998 }
101999
102000
102001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102002   int jresult ;
102003   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102004   Dali::Pixel::Format result;
102005
102006   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102007   {
102008     try {
102009       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102010     } catch (std::out_of_range& e) {
102011       {
102012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102013       };
102014     } catch (std::exception& e) {
102015       {
102016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102017       };
102018     } catch (...) {
102019       {
102020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102021       };
102022     }
102023   }
102024   jresult = (int)result;
102025   return jresult;
102026 }
102027
102028
102029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102030   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102031   Dali::Devel::PixelBuffer arg2 ;
102032   float arg3 ;
102033   bool arg4 ;
102034   Dali::Devel::PixelBuffer *argp2 ;
102035
102036   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102037   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102038   if (!argp2) {
102039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102040     return ;
102041   }
102042   arg2 = *argp2;
102043   arg3 = (float)jarg3;
102044   arg4 = jarg4 ? true : false;
102045   {
102046     try {
102047       (arg1)->ApplyMask(arg2,arg3,arg4);
102048     } catch (std::out_of_range& e) {
102049       {
102050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102051       };
102052     } catch (std::exception& e) {
102053       {
102054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102055       };
102056     } catch (...) {
102057       {
102058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102059       };
102060     }
102061   }
102062 }
102063
102064
102065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102066   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102067   Dali::Devel::PixelBuffer arg2 ;
102068   float arg3 ;
102069   Dali::Devel::PixelBuffer *argp2 ;
102070
102071   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102072   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102073   if (!argp2) {
102074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102075     return ;
102076   }
102077   arg2 = *argp2;
102078   arg3 = (float)jarg3;
102079   {
102080     try {
102081       (arg1)->ApplyMask(arg2,arg3);
102082     } catch (std::out_of_range& e) {
102083       {
102084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102085       };
102086     } catch (std::exception& e) {
102087       {
102088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102089       };
102090     } catch (...) {
102091       {
102092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102093       };
102094     }
102095   }
102096 }
102097
102098
102099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102100   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102101   Dali::Devel::PixelBuffer arg2 ;
102102   Dali::Devel::PixelBuffer *argp2 ;
102103
102104   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102105   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102106   if (!argp2) {
102107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102108     return ;
102109   }
102110   arg2 = *argp2;
102111   {
102112     try {
102113       (arg1)->ApplyMask(arg2);
102114     } catch (std::out_of_range& e) {
102115       {
102116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102117       };
102118     } catch (std::exception& e) {
102119       {
102120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102121       };
102122     } catch (...) {
102123       {
102124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102125       };
102126     }
102127   }
102128 }
102129
102130
102131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102132   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102133   float arg2 ;
102134
102135   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102136   arg2 = (float)jarg2;
102137   {
102138     try {
102139       (arg1)->ApplyGaussianBlur(arg2);
102140     } catch (std::out_of_range& e) {
102141       {
102142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102143       };
102144     } catch (std::exception& e) {
102145       {
102146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102147       };
102148     } catch (...) {
102149       {
102150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102151       };
102152     }
102153   }
102154 }
102155
102156
102157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102158   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102159   uint16_t arg2 ;
102160   uint16_t arg3 ;
102161   uint16_t arg4 ;
102162   uint16_t arg5 ;
102163
102164   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102165   arg2 = (uint16_t)jarg2;
102166   arg3 = (uint16_t)jarg3;
102167   arg4 = (uint16_t)jarg4;
102168   arg5 = (uint16_t)jarg5;
102169   {
102170     try {
102171       (arg1)->Crop(arg2,arg3,arg4,arg5);
102172     } catch (std::out_of_range& e) {
102173       {
102174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102175       };
102176     } catch (std::exception& e) {
102177       {
102178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102179       };
102180     } catch (...) {
102181       {
102182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102183       };
102184     }
102185   }
102186 }
102187
102188
102189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102190   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102191   uint16_t arg2 ;
102192   uint16_t arg3 ;
102193
102194   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102195   arg2 = (uint16_t)jarg2;
102196   arg3 = (uint16_t)jarg3;
102197   {
102198     try {
102199       (arg1)->Resize(arg2,arg3);
102200     } catch (std::out_of_range& e) {
102201       {
102202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102203       };
102204     } catch (std::exception& e) {
102205       {
102206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102207       };
102208     } catch (...) {
102209       {
102210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102211       };
102212     }
102213   }
102214 }
102215
102216
102217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102218   void * jresult ;
102219   std::string *arg1 = 0 ;
102220   Dali::ImageDimensions arg2 ;
102221   Dali::FittingMode::Type arg3 ;
102222   Dali::SamplingMode::Type arg4 ;
102223   bool arg5 ;
102224   Dali::ImageDimensions *argp2 ;
102225   Dali::Devel::PixelBuffer result;
102226
102227   if (!jarg1) {
102228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102229     return 0;
102230   }
102231   std::string arg1_str(jarg1);
102232   arg1 = &arg1_str;
102233   argp2 = (Dali::ImageDimensions *)jarg2;
102234   if (!argp2) {
102235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102236     return 0;
102237   }
102238   arg2 = *argp2;
102239   arg3 = (Dali::FittingMode::Type)jarg3;
102240   arg4 = (Dali::SamplingMode::Type)jarg4;
102241   arg5 = jarg5 ? true : false;
102242   {
102243     try {
102244       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102245     } catch (std::out_of_range& e) {
102246       {
102247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102248       };
102249     } catch (std::exception& e) {
102250       {
102251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102252       };
102253     } catch (...) {
102254       {
102255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102256       };
102257     }
102258   }
102259   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102260
102261   return jresult;
102262 }
102263
102264
102265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102266   void * jresult ;
102267   std::string *arg1 = 0 ;
102268   Dali::ImageDimensions arg2 ;
102269   Dali::FittingMode::Type arg3 ;
102270   Dali::SamplingMode::Type arg4 ;
102271   Dali::ImageDimensions *argp2 ;
102272   Dali::Devel::PixelBuffer result;
102273
102274   if (!jarg1) {
102275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102276     return 0;
102277   }
102278   std::string arg1_str(jarg1);
102279   arg1 = &arg1_str;
102280   argp2 = (Dali::ImageDimensions *)jarg2;
102281   if (!argp2) {
102282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102283     return 0;
102284   }
102285   arg2 = *argp2;
102286   arg3 = (Dali::FittingMode::Type)jarg3;
102287   arg4 = (Dali::SamplingMode::Type)jarg4;
102288   {
102289     try {
102290       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102291     } catch (std::out_of_range& e) {
102292       {
102293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102294       };
102295     } catch (std::exception& e) {
102296       {
102297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102298       };
102299     } catch (...) {
102300       {
102301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102302       };
102303     }
102304   }
102305   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102306
102307   return jresult;
102308 }
102309
102310
102311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102312   void * jresult ;
102313   std::string *arg1 = 0 ;
102314   Dali::ImageDimensions arg2 ;
102315   Dali::FittingMode::Type arg3 ;
102316   Dali::ImageDimensions *argp2 ;
102317   Dali::Devel::PixelBuffer result;
102318
102319   if (!jarg1) {
102320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102321     return 0;
102322   }
102323   std::string arg1_str(jarg1);
102324   arg1 = &arg1_str;
102325   argp2 = (Dali::ImageDimensions *)jarg2;
102326   if (!argp2) {
102327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102328     return 0;
102329   }
102330   arg2 = *argp2;
102331   arg3 = (Dali::FittingMode::Type)jarg3;
102332   {
102333     try {
102334       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102335     } catch (std::out_of_range& e) {
102336       {
102337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102338       };
102339     } catch (std::exception& e) {
102340       {
102341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102342       };
102343     } catch (...) {
102344       {
102345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102346       };
102347     }
102348   }
102349   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102350
102351   return jresult;
102352 }
102353
102354
102355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102356   void * jresult ;
102357   std::string *arg1 = 0 ;
102358   Dali::ImageDimensions arg2 ;
102359   Dali::ImageDimensions *argp2 ;
102360   Dali::Devel::PixelBuffer result;
102361
102362   if (!jarg1) {
102363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102364     return 0;
102365   }
102366   std::string arg1_str(jarg1);
102367   arg1 = &arg1_str;
102368   argp2 = (Dali::ImageDimensions *)jarg2;
102369   if (!argp2) {
102370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102371     return 0;
102372   }
102373   arg2 = *argp2;
102374   {
102375     try {
102376       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
102377     } catch (std::out_of_range& e) {
102378       {
102379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102380       };
102381     } catch (std::exception& e) {
102382       {
102383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102384       };
102385     } catch (...) {
102386       {
102387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102388       };
102389     }
102390   }
102391   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102392
102393   return jresult;
102394 }
102395
102396
102397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
102398   void * jresult ;
102399   std::string *arg1 = 0 ;
102400   Dali::Devel::PixelBuffer result;
102401
102402   if (!jarg1) {
102403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102404     return 0;
102405   }
102406   std::string arg1_str(jarg1);
102407   arg1 = &arg1_str;
102408   {
102409     try {
102410       result = Dali::LoadImageFromFile((std::string const &)*arg1);
102411     } catch (std::out_of_range& e) {
102412       {
102413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102414       };
102415     } catch (std::exception& e) {
102416       {
102417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102418       };
102419     } catch (...) {
102420       {
102421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102422       };
102423     }
102424   }
102425   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102426
102427   return jresult;
102428 }
102429
102430
102431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102432   void * jresult ;
102433   std::string *arg1 = 0 ;
102434   Dali::ImageDimensions arg2 ;
102435   Dali::FittingMode::Type arg3 ;
102436   Dali::SamplingMode::Type arg4 ;
102437   bool arg5 ;
102438   Dali::ImageDimensions *argp2 ;
102439   Dali::ImageDimensions result;
102440
102441   if (!jarg1) {
102442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102443     return 0;
102444   }
102445   std::string arg1_str(jarg1);
102446   arg1 = &arg1_str;
102447   argp2 = (Dali::ImageDimensions *)jarg2;
102448   if (!argp2) {
102449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102450     return 0;
102451   }
102452   arg2 = *argp2;
102453   arg3 = (Dali::FittingMode::Type)jarg3;
102454   arg4 = (Dali::SamplingMode::Type)jarg4;
102455   arg5 = jarg5 ? true : false;
102456   {
102457     try {
102458       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102459     } catch (std::out_of_range& e) {
102460       {
102461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102462       };
102463     } catch (std::exception& e) {
102464       {
102465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102466       };
102467     } catch (...) {
102468       {
102469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102470       };
102471     }
102472   }
102473   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102474
102475   return jresult;
102476 }
102477
102478
102479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102480   void * jresult ;
102481   std::string *arg1 = 0 ;
102482   Dali::ImageDimensions arg2 ;
102483   Dali::FittingMode::Type arg3 ;
102484   Dali::SamplingMode::Type arg4 ;
102485   Dali::ImageDimensions *argp2 ;
102486   Dali::ImageDimensions result;
102487
102488   if (!jarg1) {
102489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102490     return 0;
102491   }
102492   std::string arg1_str(jarg1);
102493   arg1 = &arg1_str;
102494   argp2 = (Dali::ImageDimensions *)jarg2;
102495   if (!argp2) {
102496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102497     return 0;
102498   }
102499   arg2 = *argp2;
102500   arg3 = (Dali::FittingMode::Type)jarg3;
102501   arg4 = (Dali::SamplingMode::Type)jarg4;
102502   {
102503     try {
102504       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
102505     } catch (std::out_of_range& e) {
102506       {
102507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102508       };
102509     } catch (std::exception& e) {
102510       {
102511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102512       };
102513     } catch (...) {
102514       {
102515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102516       };
102517     }
102518   }
102519   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102520
102521   return jresult;
102522 }
102523
102524
102525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102526   void * jresult ;
102527   std::string *arg1 = 0 ;
102528   Dali::ImageDimensions arg2 ;
102529   Dali::FittingMode::Type arg3 ;
102530   Dali::ImageDimensions *argp2 ;
102531   Dali::ImageDimensions result;
102532
102533   if (!jarg1) {
102534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102535     return 0;
102536   }
102537   std::string arg1_str(jarg1);
102538   arg1 = &arg1_str;
102539   argp2 = (Dali::ImageDimensions *)jarg2;
102540   if (!argp2) {
102541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102542     return 0;
102543   }
102544   arg2 = *argp2;
102545   arg3 = (Dali::FittingMode::Type)jarg3;
102546   {
102547     try {
102548       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
102549     } catch (std::out_of_range& e) {
102550       {
102551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102552       };
102553     } catch (std::exception& e) {
102554       {
102555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102556       };
102557     } catch (...) {
102558       {
102559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102560       };
102561     }
102562   }
102563   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102564
102565   return jresult;
102566 }
102567
102568
102569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
102570   void * jresult ;
102571   std::string *arg1 = 0 ;
102572   Dali::ImageDimensions arg2 ;
102573   Dali::ImageDimensions *argp2 ;
102574   Dali::ImageDimensions result;
102575
102576   if (!jarg1) {
102577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102578     return 0;
102579   }
102580   std::string arg1_str(jarg1);
102581   arg1 = &arg1_str;
102582   argp2 = (Dali::ImageDimensions *)jarg2;
102583   if (!argp2) {
102584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102585     return 0;
102586   }
102587   arg2 = *argp2;
102588   {
102589     try {
102590       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
102591     } catch (std::out_of_range& e) {
102592       {
102593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102594       };
102595     } catch (std::exception& e) {
102596       {
102597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102598       };
102599     } catch (...) {
102600       {
102601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102602       };
102603     }
102604   }
102605   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102606
102607   return jresult;
102608 }
102609
102610
102611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
102612   void * jresult ;
102613   std::string *arg1 = 0 ;
102614   Dali::ImageDimensions result;
102615
102616   if (!jarg1) {
102617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102618     return 0;
102619   }
102620   std::string arg1_str(jarg1);
102621   arg1 = &arg1_str;
102622   {
102623     try {
102624       result = Dali::GetClosestImageSize((std::string const &)*arg1);
102625     } catch (std::out_of_range& e) {
102626       {
102627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102628       };
102629     } catch (std::exception& e) {
102630       {
102631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102632       };
102633     } catch (...) {
102634       {
102635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102636       };
102637     }
102638   }
102639   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102640
102641   return jresult;
102642 }
102643
102644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
102645   void * jresult ;
102646   std::string *arg1 = 0 ;
102647   Dali::ImageDimensions result;
102648
102649   if (!jarg1) {
102650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102651     return 0;
102652   }
102653   std::string arg1_str(jarg1);
102654   arg1 = &arg1_str;
102655   {
102656     try {
102657       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
102658     } catch (std::out_of_range& e) {
102659       {
102660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102661       };
102662     } catch (std::exception& e) {
102663       {
102664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102665       };
102666     } catch (...) {
102667       {
102668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102669       };
102670     }
102671   }
102672   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102673
102674   return jresult;
102675 }
102676
102677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102678   void * jresult ;
102679   std::string *arg1 = 0 ;
102680   Dali::ImageDimensions arg2 ;
102681   Dali::FittingMode::Type arg3 ;
102682   Dali::SamplingMode::Type arg4 ;
102683   bool arg5 ;
102684   Dali::ImageDimensions *argp2 ;
102685   Dali::Devel::PixelBuffer result;
102686
102687   if (!jarg1) {
102688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102689     return 0;
102690   }
102691   std::string arg1_str(jarg1);
102692   arg1 = &arg1_str;
102693   argp2 = (Dali::ImageDimensions *)jarg2;
102694   if (!argp2) {
102695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102696     return 0;
102697   }
102698   arg2 = *argp2;
102699   arg3 = (Dali::FittingMode::Type)jarg3;
102700   arg4 = (Dali::SamplingMode::Type)jarg4;
102701   arg5 = jarg5 ? true : false;
102702   {
102703     try {
102704       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102705     } catch (std::out_of_range& e) {
102706       {
102707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102708       };
102709     } catch (std::exception& e) {
102710       {
102711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102712       };
102713     } catch (...) {
102714       {
102715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102716       };
102717     }
102718   }
102719   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102720
102721   return jresult;
102722 }
102723
102724
102725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102726   void * jresult ;
102727   std::string *arg1 = 0 ;
102728   Dali::ImageDimensions arg2 ;
102729   Dali::FittingMode::Type arg3 ;
102730   Dali::SamplingMode::Type arg4 ;
102731   Dali::ImageDimensions *argp2 ;
102732   Dali::Devel::PixelBuffer result;
102733
102734   if (!jarg1) {
102735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102736     return 0;
102737   }
102738   std::string arg1_str(jarg1);
102739   arg1 = &arg1_str;
102740   argp2 = (Dali::ImageDimensions *)jarg2;
102741   if (!argp2) {
102742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102743     return 0;
102744   }
102745   arg2 = *argp2;
102746   arg3 = (Dali::FittingMode::Type)jarg3;
102747   arg4 = (Dali::SamplingMode::Type)jarg4;
102748   {
102749     try {
102750       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102751     } catch (std::out_of_range& e) {
102752       {
102753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102754       };
102755     } catch (std::exception& e) {
102756       {
102757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102758       };
102759     } catch (...) {
102760       {
102761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102762       };
102763     }
102764   }
102765   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102766
102767   return jresult;
102768 }
102769
102770
102771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102772   void * jresult ;
102773   std::string *arg1 = 0 ;
102774   Dali::ImageDimensions arg2 ;
102775   Dali::FittingMode::Type arg3 ;
102776   Dali::ImageDimensions *argp2 ;
102777   Dali::Devel::PixelBuffer result;
102778
102779   if (!jarg1) {
102780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102781     return 0;
102782   }
102783   std::string arg1_str(jarg1);
102784   arg1 = &arg1_str;
102785   argp2 = (Dali::ImageDimensions *)jarg2;
102786   if (!argp2) {
102787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102788     return 0;
102789   }
102790   arg2 = *argp2;
102791   arg3 = (Dali::FittingMode::Type)jarg3;
102792   {
102793     try {
102794       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102795     } catch (std::out_of_range& e) {
102796       {
102797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102798       };
102799     } catch (std::exception& e) {
102800       {
102801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102802       };
102803     } catch (...) {
102804       {
102805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102806       };
102807     }
102808   }
102809   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102810
102811   return jresult;
102812 }
102813
102814
102815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102816   void * jresult ;
102817   std::string *arg1 = 0 ;
102818   Dali::ImageDimensions arg2 ;
102819   Dali::ImageDimensions *argp2 ;
102820   Dali::Devel::PixelBuffer result;
102821
102822   if (!jarg1) {
102823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102824     return 0;
102825   }
102826   std::string arg1_str(jarg1);
102827   arg1 = &arg1_str;
102828   argp2 = (Dali::ImageDimensions *)jarg2;
102829   if (!argp2) {
102830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102831     return 0;
102832   }
102833   arg2 = *argp2;
102834   {
102835     try {
102836       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
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 (...) {
102846       {
102847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102848       };
102849     }
102850   }
102851   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102852
102853   return jresult;
102854 }
102855
102856
102857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102858   void * jresult ;
102859   std::string *arg1 = 0 ;
102860   Dali::Devel::PixelBuffer result;
102861
102862   if (!jarg1) {
102863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102864     return 0;
102865   }
102866   std::string arg1_str(jarg1);
102867   arg1 = &arg1_str;
102868   {
102869     try {
102870       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102871     } catch (std::out_of_range& e) {
102872       {
102873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102874       };
102875     } catch (std::exception& e) {
102876       {
102877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102878       };
102879     } catch (...) {
102880       {
102881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102882       };
102883     }
102884   }
102885   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102886
102887   return jresult;
102888 }
102889
102890
102891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
102892   void * jresult ;
102893   Dali::Toolkit::WebView result;
102894
102895   {
102896     try {
102897       result = Dali::Toolkit::WebView::New();
102898     } catch (std::out_of_range& e) {
102899       {
102900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102901       };
102902     } catch (std::exception& e) {
102903       {
102904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102905       };
102906     } catch (Dali::DaliException e) {
102907       {
102908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102909       };
102910     } catch (...) {
102911       {
102912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102913       };
102914     }
102915   }
102916   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102917   return jresult;
102918 }
102919
102920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
102921   void * jresult ;
102922   Dali::Toolkit::WebView result;
102923
102924   std::string *arg1;
102925   std::string *arg2;
102926
102927   if (!jarg1) {
102928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
102929     return 0;
102930   }
102931   if (!jarg2) {
102932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
102933     return 0;
102934   }
102935
102936   std::string jarg1_str = std::string(jarg1);
102937   std::string jarg2_str = std::string(jarg2);
102938
102939   arg1 = &jarg1_str;
102940   arg2 = &jarg2_str;
102941
102942   {
102943     try {
102944       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102945     } catch (std::out_of_range& e) {
102946       {
102947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102948       };
102949     } catch (std::exception& e) {
102950       {
102951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102952       };
102953     } catch (Dali::DaliException e) {
102954       {
102955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102956       };
102957     } catch (...) {
102958       {
102959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102960       };
102961     }
102962   }
102963   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102964   return jresult;
102965 }
102966
102967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102968   void * jresult ;
102969   Dali::Toolkit::WebView *arg1 = 0 ;
102970   Dali::Toolkit::WebView *result = 0 ;
102971
102972   arg1 = (Dali::Toolkit::WebView *)jarg1;
102973   if (!arg1) {
102974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102975     return 0;
102976   }
102977   {
102978     try {
102979       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102980     } catch (std::out_of_range& e) {
102981       {
102982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102983       };
102984     } catch (std::exception& e) {
102985       {
102986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102987       };
102988     } catch (Dali::DaliException e) {
102989       {
102990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102991       };
102992     } catch (...) {
102993       {
102994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102995       };
102996     }
102997   }
102998   jresult = (void *)result;
102999   return jresult;
103000 }
103001
103002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
103003   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103004   arg1 = (Dali::Toolkit::WebView *)jarg1;
103005   {
103006     try {
103007       delete arg1;
103008     } catch (std::out_of_range& e) {
103009       {
103010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103011       };
103012     } catch (std::exception& e) {
103013       {
103014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103015       };
103016     } catch (Dali::DaliException e) {
103017       {
103018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103019       };
103020     } catch (...) {
103021       {
103022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103023       };
103024     }
103025   }
103026 }
103027
103028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103029   void * jresult ;
103030   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103031   Dali::Toolkit::WebView *arg2 = 0 ;
103032   Dali::Toolkit::WebView *result = 0 ;
103033
103034   arg1 = (Dali::Toolkit::WebView *)jarg1;
103035   arg2 = (Dali::Toolkit::WebView *)jarg2;
103036   if (!arg2) {
103037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103038     return 0;
103039   }
103040   {
103041     try {
103042       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103043     } catch (std::out_of_range& e) {
103044       {
103045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103046       };
103047     } catch (std::exception& e) {
103048       {
103049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103050       };
103051     } catch (Dali::DaliException e) {
103052       {
103053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103054       };
103055     } catch (...) {
103056       {
103057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103058       };
103059     }
103060   }
103061   jresult = (void *)result;
103062   return jresult;
103063 }
103064
103065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103066   void * jresult ;
103067   Dali::BaseHandle arg1 ;
103068   Dali::BaseHandle *argp1 ;
103069   Dali::Toolkit::WebView result;
103070
103071   argp1 = (Dali::BaseHandle *)jarg1;
103072   if (!argp1) {
103073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103074     return 0;
103075   }
103076   arg1 = *argp1;
103077   {
103078     try {
103079       result = Dali::Toolkit::WebView::DownCast(arg1);
103080     } catch (std::out_of_range& e) {
103081       {
103082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103083       };
103084     } catch (std::exception& e) {
103085       {
103086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103087       };
103088     } catch (Dali::DaliException e) {
103089       {
103090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103091       };
103092     } catch (...) {
103093       {
103094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103095       };
103096     }
103097   }
103098   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103099   return jresult;
103100 }
103101
103102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
103103   return (int) Dali::Toolkit::WebView::Property::URL;
103104 }
103105
103106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
103107   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
103108 }
103109
103110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
103111   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
103112 }
103113
103114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
103115   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
103116 }
103117
103118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
103119   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
103120 }
103121
103122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
103123   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
103124 }
103125
103126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
103127   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
103128 }
103129
103130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
103131   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
103132 }
103133
103134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103135   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103136   std::string *arg2;
103137
103138   arg1 = (Dali::Toolkit::WebView *)jarg1;
103139
103140   if (!jarg2) {
103141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103142     return;
103143   }
103144
103145   std::string jarg2str = std::string(jarg2);
103146   arg2 = &jarg2str;
103147   {
103148     try {
103149       (arg1)->LoadUrl((std::string const &)*arg2);
103150     } catch (std::out_of_range& e) {
103151       {
103152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103153       };
103154     } catch (std::exception& e) {
103155       {
103156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103157       };
103158     } catch (Dali::DaliException e) {
103159       {
103160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103161       };
103162     } catch (...) {
103163       {
103164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103165       };
103166     }
103167   }
103168 }
103169
103170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103171   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103172   std::string *arg2;
103173
103174   arg1 = (Dali::Toolkit::WebView *)jarg1;
103175   if (!jarg2) {
103176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103177     return;
103178   }
103179   std::string jarg2str = std::string(jarg2);
103180   arg2 = &jarg2str;
103181   {
103182     try {
103183       (arg1)->LoadHTMLString((std::string const &)*arg2);
103184     } catch (std::out_of_range& e) {
103185       {
103186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103187       };
103188     } catch (std::exception& e) {
103189       {
103190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103191       };
103192     } catch (Dali::DaliException e) {
103193       {
103194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103195       };
103196     } catch (...) {
103197       {
103198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103199       };
103200     }
103201   }
103202 }
103203
103204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103205   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103206
103207   arg1 = (Dali::Toolkit::WebView *)jarg1;
103208   {
103209     try {
103210       (arg1)->Reload();
103211     } catch (std::out_of_range& e) {
103212       {
103213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103214       };
103215     } catch (std::exception& e) {
103216       {
103217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103218       };
103219     } catch (Dali::DaliException e) {
103220       {
103221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103222       };
103223     } catch (...) {
103224       {
103225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103226       };
103227     }
103228   }
103229 }
103230
103231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103232   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103233
103234   arg1 = (Dali::Toolkit::WebView *)jarg1;
103235   {
103236     try {
103237       (arg1)->StopLoading();
103238     } catch (std::out_of_range& e) {
103239       {
103240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103241       };
103242     } catch (std::exception& e) {
103243       {
103244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103245       };
103246     } catch (Dali::DaliException e) {
103247       {
103248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103249       };
103250     } catch (...) {
103251       {
103252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103253       };
103254     }
103255   }
103256 }
103257
103258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
103259   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103260
103261   arg1 = (Dali::Toolkit::WebView *)jarg1;
103262   {
103263     try {
103264       (arg1)->Suspend();
103265     } catch (std::out_of_range& e) {
103266       {
103267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103268       };
103269     } catch (std::exception& e) {
103270       {
103271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103272       };
103273     } catch (Dali::DaliException e) {
103274       {
103275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103276       };
103277     } catch (...) {
103278       {
103279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103280       };
103281     }
103282   }
103283 }
103284
103285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
103286   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103287
103288   arg1 = (Dali::Toolkit::WebView *)jarg1;
103289   {
103290     try {
103291       (arg1)->Resume();
103292     } catch (std::out_of_range& e) {
103293       {
103294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103295       };
103296     } catch (std::exception& e) {
103297       {
103298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103299       };
103300     } catch (Dali::DaliException e) {
103301       {
103302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103303       };
103304     } catch (...) {
103305       {
103306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103307       };
103308     }
103309   }
103310 }
103311
103312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103313   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103314
103315   arg1 = (Dali::Toolkit::WebView *)jarg1;
103316   {
103317     try {
103318       (arg1)->GoBack();
103319     } catch (std::out_of_range& e) {
103320       {
103321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103322       };
103323     } catch (std::exception& e) {
103324       {
103325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103326       };
103327     } catch (Dali::DaliException e) {
103328       {
103329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103330       };
103331     } catch (...) {
103332       {
103333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103334       };
103335     }
103336   }
103337 }
103338
103339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103340   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103341
103342   arg1 = (Dali::Toolkit::WebView *)jarg1;
103343   {
103344     try {
103345       (arg1)->GoForward();
103346     } catch (std::out_of_range& e) {
103347       {
103348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103349       };
103350     } catch (std::exception& e) {
103351       {
103352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103353       };
103354     } catch (Dali::DaliException e) {
103355       {
103356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103357       };
103358     } catch (...) {
103359       {
103360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103361       };
103362     }
103363   }
103364 }
103365
103366 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103367   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103368   bool ret;
103369
103370   arg1 = (Dali::Toolkit::WebView *)jarg1;
103371   {
103372     try {
103373       ret = (arg1)->CanGoBack();
103374     } catch (std::out_of_range& e) {
103375       {
103376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103377       };
103378     } catch (std::exception& e) {
103379       {
103380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103381       };
103382     } catch (Dali::DaliException e) {
103383       {
103384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103385       };
103386     } catch (...) {
103387       {
103388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103389       };
103390     }
103391   }
103392   return ret;
103393 }
103394
103395 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103396   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103397   bool ret;
103398
103399   arg1 = (Dali::Toolkit::WebView *)jarg1;
103400   {
103401     try {
103402       ret = (arg1)->CanGoForward();
103403     } catch (std::out_of_range& e) {
103404       {
103405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103406       };
103407     } catch (std::exception& e) {
103408       {
103409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103410       };
103411     } catch (Dali::DaliException e) {
103412       {
103413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103414       };
103415     } catch (...) {
103416       {
103417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103418       };
103419     }
103420   }
103421   return ret;
103422 }
103423
103424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
103425   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103426   std::string *arg2;
103427
103428   arg1 = (Dali::Toolkit::WebView *)jarg1;
103429   if (!jarg2) {
103430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103431     return;
103432   }
103433   std::string jarg2_str = std::string(jarg2);
103434   arg2 = &jarg2_str;
103435
103436   void (*handler)(char*) = (void (*)(char*)) jarg3;
103437
103438   {
103439     try {
103440       (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
103441         handler(SWIG_csharp_string_callback(result.c_str()));
103442       });
103443     } catch (std::out_of_range& e) {
103444       {
103445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103446       };
103447     } catch (std::exception& e) {
103448       {
103449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103450       };
103451     } catch (Dali::DaliException e) {
103452       {
103453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103454       };
103455     } catch (...) {
103456       {
103457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103458       };
103459     }
103460   }
103461 }
103462
103463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
103464 {
103465   if (!jarg2) {
103466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103467     return;
103468   }
103469
103470   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103471   std::string exposedObjectName = jarg2;
103472   void (*handler)(char*) = (void (*)(char*)) jarg3;
103473
103474   {
103475     try {
103476       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
103477         handler(SWIG_csharp_string_callback(message.c_str()));
103478       });
103479     } catch (std::out_of_range& e) {
103480       {
103481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103482       };
103483     } catch (std::exception& e) {
103484       {
103485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103486       };
103487     } catch (Dali::DaliException e) {
103488       {
103489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103490       };
103491     } catch (...) {
103492       {
103493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103494       };
103495     }
103496   }
103497 }
103498
103499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
103500   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103501
103502   arg1 = (Dali::Toolkit::WebView *)jarg1;
103503   {
103504     try {
103505       (arg1)->ClearHistory();
103506     } catch (std::out_of_range& e) {
103507       {
103508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103509       };
103510     } catch (std::exception& e) {
103511       {
103512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103513       };
103514     } catch (Dali::DaliException e) {
103515       {
103516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103517       };
103518     } catch (...) {
103519       {
103520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103521       };
103522     }
103523   }
103524 }
103525
103526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
103527   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103528
103529   arg1 = (Dali::Toolkit::WebView *)jarg1;
103530   {
103531     try {
103532       (arg1)->ClearCache();
103533     } catch (std::out_of_range& e) {
103534       {
103535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103536       };
103537     } catch (std::exception& e) {
103538       {
103539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103540       };
103541     } catch (Dali::DaliException e) {
103542       {
103543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103544       };
103545     } catch (...) {
103546       {
103547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103548       };
103549     }
103550   }
103551 }
103552
103553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
103554   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103555
103556   arg1 = (Dali::Toolkit::WebView *)jarg1;
103557   {
103558     try {
103559       (arg1)->ClearCookies();
103560     } catch (std::out_of_range& e) {
103561       {
103562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103563       };
103564     } catch (std::exception& e) {
103565       {
103566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103567       };
103568     } catch (Dali::DaliException e) {
103569       {
103570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103571       };
103572     } catch (...) {
103573       {
103574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103575       };
103576     }
103577   }
103578 }
103579
103580 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
103581     return (Dali::Toolkit::Control *)jarg1;
103582 }
103583
103584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
103585   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103586   SignalConverter::WebViewPageLoadSignal* result = NULL;
103587   {
103588     try {
103589       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
103590     } catch (std::out_of_range& e) {
103591       {
103592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103593       };
103594     } catch (std::exception& e) {
103595       {
103596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103597       };
103598     } catch (Dali::DaliException e) {
103599       {
103600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103601       };
103602     } catch (...) {
103603       {
103604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103605       };
103606     }
103607   }
103608   return (void*) result;
103609 }
103610
103611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
103612   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103613   SignalConverter::WebViewPageLoadSignal* result = NULL;
103614   {
103615     try {
103616       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
103617     } catch (std::out_of_range& e) {
103618       {
103619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103620       };
103621     } catch (std::exception& e) {
103622       {
103623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103624       };
103625     } catch (Dali::DaliException e) {
103626       {
103627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103628       };
103629     } catch (...) {
103630       {
103631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103632       };
103633     }
103634   }
103635   return (void*) result;
103636 }
103637
103638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
103639 {
103640   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103641   {
103642     try {
103643       delete object;
103644     } catch (std::out_of_range& e) {
103645       {
103646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103647       };
103648     } catch (std::exception& e) {
103649       {
103650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103651       };
103652     } catch (Dali::DaliException e) {
103653       {
103654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103655       };
103656     } catch (...) {
103657       {
103658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103659       };
103660     }
103661   }
103662 }
103663
103664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
103665 {
103666   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103667   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103668   {
103669     try {
103670       proxy->Connect(callback);
103671     } catch (std::out_of_range& e) {
103672       {
103673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103674       };
103675     } catch (std::exception& e) {
103676       {
103677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103678       };
103679     } catch (Dali::DaliException e) {
103680       {
103681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103682       };
103683     } catch (...) {
103684       {
103685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103686       };
103687     }
103688   }
103689 }
103690
103691
103692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
103693   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103694   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103695   {
103696     try {
103697       proxy->Disconnect(callback);
103698     } catch (std::out_of_range& e) {
103699       {
103700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103701       };
103702     } catch (std::exception& e) {
103703       {
103704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103705       };
103706     } catch (Dali::DaliException e) {
103707       {
103708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103709       };
103710     } catch (...) {
103711       {
103712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103713       };
103714     }
103715   }
103716 }
103717
103718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
103719   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103720   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
103721   {
103722     try {
103723       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
103724     } catch (std::out_of_range& e) {
103725       {
103726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103727       };
103728     } catch (std::exception& e) {
103729       {
103730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103731       };
103732     } catch (Dali::DaliException e) {
103733       {
103734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103735       };
103736     } catch (...) {
103737       {
103738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103739       };
103740     }
103741   }
103742   return (void*) result;
103743 }
103744
103745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
103746 {
103747   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103748   {
103749     try {
103750       delete object;
103751     } catch (std::out_of_range& e) {
103752       {
103753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103754       };
103755     } catch (std::exception& e) {
103756       {
103757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103758       };
103759     } catch (Dali::DaliException e) {
103760       {
103761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103762       };
103763     } catch (...) {
103764       {
103765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103766       };
103767     }
103768   }
103769 }
103770
103771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
103772 {
103773   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103774   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103775   {
103776     try {
103777       proxy->Connect(callback);
103778     } catch (std::out_of_range& e) {
103779       {
103780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103781       };
103782     } catch (std::exception& e) {
103783       {
103784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103785       };
103786     } catch (Dali::DaliException e) {
103787       {
103788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103789       };
103790     } catch (...) {
103791       {
103792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103793       };
103794     }
103795   }
103796 }
103797
103798
103799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
103800   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103801   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103802   {
103803     try {
103804       proxy->Disconnect(callback);
103805     } catch (std::out_of_range& e) {
103806       {
103807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103808       };
103809     } catch (std::exception& e) {
103810       {
103811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103812       };
103813     } catch (Dali::DaliException e) {
103814       {
103815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103816       };
103817     } catch (...) {
103818       {
103819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103820       };
103821     }
103822   }
103823 }
103824
103825 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
103826   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
103827   char * jresult = SWIG_csharp_string_callback((const char *)result);
103828   return jresult;
103829 }
103830
103831 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
103832   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
103833   return result;
103834 }
103835
103836 #ifdef __cplusplus
103837 }
103838 #endif
103839