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/drag-and-drop-detector.h>
 439 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467
 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
 477
 478 // add here SWIG version check
 479
 480 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 481 // disable Swig-dependent warnings
 482
 483 // 'identifier1' has C-linkage specified,
 484 // but returns UDT 'identifier2' which is incompatible with C
 485 #pragma warning(disable: 4190)
 486
 487 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 488 #pragma warning(disable: 4800)
 489
 490 // debug info too long etc etc
 491 #pragma warning(disable: 4786)
 492 #endif
 493
 494
 495 #include <stdexcept>
 496
 497
 498 #include <string>
 499
 500
 501 #include <vector>
 502 #include <algorithm>
 503 #include <stdexcept>
 504
 505
 506 #include <map>
 507 #include <algorithm>
 508 #include <stdexcept>
 509
 510
 511 #include <utility>
 512
 513
 514 typedef float floatp;
 515
 516 SWIGINTERN floatp *new_floatp(){
 517   return new float();
 518 }
 519 SWIGINTERN void delete_floatp(floatp *self){
 520   if (self) delete self;
 521 }
 522 SWIGINTERN void floatp_assign(floatp *self,float value){
 523   *self = value;
 524 }
 525 SWIGINTERN float floatp_value(floatp *self){
 526   return *self;
 527 }
 528 SWIGINTERN float *floatp_cast(floatp *self){
 529   return self;
 530 }
 531 SWIGINTERN floatp *floatp_frompointer(float *t){
 532   return (floatp *) t;
 533 }
 534
 535 typedef int intp;
 536
 537 SWIGINTERN intp *new_intp(){
 538   return new int();
 539 }
 540 SWIGINTERN void delete_intp(intp *self){
 541   if (self) delete self;
 542 }
 543 SWIGINTERN void intp_assign(intp *self,int value){
 544   *self = value;
 545 }
 546 SWIGINTERN int intp_value(intp *self){
 547   return *self;
 548 }
 549 SWIGINTERN int *intp_cast(intp *self){
 550   return self;
 551 }
 552 SWIGINTERN intp *intp_frompointer(int *t){
 553   return (intp *) t;
 554 }
 555
 556 typedef double doublep;
 557
 558 SWIGINTERN doublep *new_doublep(){
 559   return new double();
 560 }
 561 SWIGINTERN void delete_doublep(doublep *self){
 562   if (self) delete self;
 563 }
 564 SWIGINTERN void doublep_assign(doublep *self,double value){
 565   *self = value;
 566 }
 567 SWIGINTERN double doublep_value(doublep *self){
 568   return *self;
 569 }
 570 SWIGINTERN double *doublep_cast(doublep *self){
 571   return self;
 572 }
 573 SWIGINTERN doublep *doublep_frompointer(double *t){
 574   return (doublep *) t;
 575 }
 576
 577 typedef unsigned int uintp;
 578
 579 SWIGINTERN uintp *new_uintp(){
 580   return new unsigned int();
 581 }
 582 SWIGINTERN void delete_uintp(uintp *self){
 583   if (self) delete self;
 584 }
 585 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 586   *self = value;
 587 }
 588 SWIGINTERN unsigned int uintp_value(uintp *self){
 589   return *self;
 590 }
 591 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 592   return self;
 593 }
 594 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 595   return (uintp *) t;
 596 }
 597
 598 typedef unsigned short ushortp;
 599
 600 SWIGINTERN ushortp *new_ushortp(){
 601   return new unsigned short();
 602 }
 603 SWIGINTERN void delete_ushortp(ushortp *self){
 604   if (self) delete self;
 605 }
 606 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 607   *self = value;
 608 }
 609 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 610   return *self;
 611 }
 612 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 613   return self;
 614 }
 615 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 616   return (ushortp *) t;
 617 }
 618
 619 unsigned int int_to_uint(int x) {
 620    return (unsigned int) x;
 621 }
 622
 623
 624 using namespace Dali;
 625 using namespace Dali::Toolkit;
 626
 627 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 628 {
 629   bool result = false;
 630   try
 631   {
 632     // C++ code. DALi uses Handle <-> Body design pattern.
 633     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 634     // Handles in DALi can be converted into a boolean type
 635     // to check if the handle has a valid body attached to it.
 636     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 637     if( *self )
 638     {
 639       result = true;
 640     }
 641     else
 642     {
 643       result = false;
 644     }
 645   }
 646   catch (std::out_of_range& e)
 647   {
 648     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 649     return 0;
 650   }
 651   catch (std::exception& e)
 652   {
 653     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 654     return 0;
 655   }
 656   catch (DaliException e)
 657   {
 658     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 659     return 0;
 660   }
 661   catch (...)
 662   {
 663     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 664     return 0;
 665   }
 666   return result;
 667 }
 668
 669 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 670 {
 671   bool result = false;
 672   try
 673   {
 674     // C++ code. Check if two handles reference the same implemtion
 675     if( *self == rhs)
 676     {
 677       result = true;
 678     }
 679     else
 680     {
 681       result = false;
 682     }
 683   }
 684   catch (std::out_of_range& e)
 685   {
 686     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 687     return 0;
 688   }
 689   catch (std::exception& e)
 690   {
 691     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 692     return 0;
 693   }
 694   catch (DaliException e)
 695   {
 696     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 697     return 0;
 698   }
 699   catch (...)
 700   {
 701     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 702     return 0;
 703   }
 704   return result;
 705 }
 706
 707
 708 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 709      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 710    }
 711 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){
 712      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 713    }
 714 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 715         std::vector< Dali::TouchPoint >* pv = 0;
 716         if (capacity >= 0) {
 717           pv = new std::vector< Dali::TouchPoint >();
 718           pv->reserve(capacity);
 719        } else {
 720           throw std::out_of_range("capacity");
 721        }
 722        return pv;
 723       }
 724 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 725         if (index>=0 && index<(int)self->size())
 726           return (*self)[index];
 727         else
 728           throw std::out_of_range("index");
 729       }
 730 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 731         if (index>=0 && index<(int)self->size())
 732           return (*self)[index];
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 737         if (index>=0 && index<(int)self->size())
 738           (*self)[index] = val;
 739         else
 740           throw std::out_of_range("index");
 741       }
 742 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 743         self->insert(self->end(), values.begin(), values.end());
 744       }
 745 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 746         if (index < 0)
 747           throw std::out_of_range("index");
 748         if (count < 0)
 749           throw std::out_of_range("count");
 750         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 751           throw std::invalid_argument("invalid range");
 752         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 753       }
 754 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 755         if (index>=0 && index<(int)self->size()+1)
 756           self->insert(self->begin()+index, x);
 757         else
 758           throw std::out_of_range("index");
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 761         if (index>=0 && index<(int)self->size()+1)
 762           self->insert(self->begin()+index, values.begin(), values.end());
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 767         if (index>=0 && index<(int)self->size())
 768           self->erase(self->begin() + index);
 769         else
 770           throw std::out_of_range("index");
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 773         if (index < 0)
 774           throw std::out_of_range("index");
 775         if (count < 0)
 776           throw std::out_of_range("count");
 777         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 778           throw std::invalid_argument("invalid range");
 779         self->erase(self->begin()+index, self->begin()+index+count);
 780       }
 781 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 782         if (count < 0)
 783           throw std::out_of_range("count");
 784         return new std::vector< Dali::TouchPoint >(count, value);
 785       }
 786 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 787         std::reverse(self->begin(), self->end());
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 790         if (index < 0)
 791           throw std::out_of_range("index");
 792         if (count < 0)
 793           throw std::out_of_range("count");
 794         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 795           throw std::invalid_argument("invalid range");
 796         std::reverse(self->begin()+index, self->begin()+index+count);
 797       }
 798 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 799         if (index < 0)
 800           throw std::out_of_range("index");
 801         if (index+values.size() > self->size())
 802           throw std::out_of_range("index");
 803         std::copy(values.begin(), values.end(), self->begin()+index);
 804       }
 805 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 806          return self->Empty();
 807       }
 808 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 809         return self->GetConnectionCount();
 810       }
 811 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 812           self->Connect( func );
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 815           self->Disconnect( func );
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 818           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 819 /*@SWIG@*/ self->Emit( arg );
 820       }
 821 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 822          return self->Empty();
 823       }
 824 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 825         return self->GetConnectionCount();
 826       }
 827 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 828           self->Connect( func );
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 831           self->Disconnect( func );
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 834           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 835 /*@SWIG@*/ self->Emit( arg );
 836       }
 837 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 838          return self->Empty();
 839       }
 840 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){
 841         return self->GetConnectionCount();
 842       }
 843 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 *)){
 844           self->Connect( func );
 845       }
 846 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 *)){
 847           self->Disconnect( func );
 848       }
 849 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){
 850           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 851 /*@SWIG@*/ self->Emit( arg );
 852       }
 853 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 854          return self->Empty();
 855       }
 856 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 857         return self->GetConnectionCount();
 858       }
 859 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 860           self->Connect( func );
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 863           self->Disconnect( func );
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 866           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 867 /*@SWIG@*/ self->Emit( arg );
 868       }
 869 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 870          return self->Empty();
 871       }
 872 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 873         return self->GetConnectionCount();
 874       }
 875 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 876           self->Connect( func );
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 879           self->Disconnect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 882           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 883 /*@SWIG@*/ self->Emit( arg );
 884       }
 885 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){
 886          return self->Empty();
 887       }
 888 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){
 889         return self->GetConnectionCount();
 890       }
 891 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 &)){
 892         self->Connect( func );
 893       }
 894 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 &)){
 895         self->Disconnect( func );
 896       }
 897 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){
 898         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 899 /*@SWIG@*/ self->Emit( arg1, arg2 );
 900       }
 901 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){
 902          return self->Empty();
 903       }
 904 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){
 905         return self->GetConnectionCount();
 906       }
 907 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 &)){
 908         self->Connect( func );
 909       }
 910 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 &)){
 911         self->Disconnect( func );
 912       }
 913 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){
 914         return self->Emit( arg1, arg2 );
 915       }
 916 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){
 917          return self->Empty();
 918       }
 919 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){
 920         return self->GetConnectionCount();
 921       }
 922 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 &)){
 923         self->Connect( func );
 924       }
 925 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 &)){
 926         self->Disconnect( func );
 927       }
 928 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){
 929         return self->Emit( arg1, arg2 );
 930       }
 931 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){
 932          return self->Empty();
 933       }
 934 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){
 935         return self->GetConnectionCount();
 936       }
 937 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 &)){
 938         self->Connect( func );
 939       }
 940 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 &)){
 941         self->Disconnect( func );
 942       }
 943 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){
 944         return self->Emit( arg1, arg2 );
 945       }
 946 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 947          return self->Empty();
 948       }
 949 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 950         return self->GetConnectionCount();
 951       }
 952 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 953           self->Connect( func );
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 956           self->Disconnect( func );
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 959           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 960 /*@SWIG@*/ self->Emit( arg );
 961       }
 962 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 963          return self->Empty();
 964       }
 965 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){
 966         return self->GetConnectionCount();
 967       }
 968 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 &)){
 969           self->Connect( func );
 970       }
 971 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 &)){
 972           self->Disconnect( func );
 973       }
 974 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){
 975           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 976 /*@SWIG@*/ self->Emit( arg );
 977       }
 978 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 979          return self->Empty();
 980       }
 981 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){
 982         return self->GetConnectionCount();
 983       }
 984 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 &)){
 985           self->Connect( func );
 986       }
 987 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 &)){
 988           self->Disconnect( func );
 989       }
 990 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){
 991           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 992 /*@SWIG@*/ self->Emit( arg );
 993       }
 994 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 995          return self->Empty();
 996       }
 997 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){
 998         return self->GetConnectionCount();
 999       }
1000 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 &)){
1001           self->Connect( func );
1002       }
1003 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 &)){
1004           self->Disconnect( func );
1005       }
1006 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){
1007           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1008 /*@SWIG@*/ self->Emit( arg );
1009       }
1010 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){
1011          return self->Empty();
1012       }
1013 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){
1014         return self->GetConnectionCount();
1015       }
1016 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 &)){
1017         self->Connect( func );
1018       }
1019 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 &)){
1020         self->Disconnect( func );
1021       }
1022 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){
1023         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1024 /*@SWIG@*/ self->Emit( arg1, arg2 );
1025       }
1026 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){
1027          return self->Empty();
1028       }
1029 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){
1030         return self->GetConnectionCount();
1031       }
1032 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 &)){
1033         self->Connect( func );
1034       }
1035 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 &)){
1036         self->Disconnect( func );
1037       }
1038 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){
1039         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1040 /*@SWIG@*/ self->Emit( arg1, arg2 );
1041       }
1042 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){
1043          return self->Empty();
1044       }
1045 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){
1046         return self->GetConnectionCount();
1047       }
1048 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 &)){
1049         self->Connect( func );
1050       }
1051 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 &)){
1052         self->Disconnect( func );
1053       }
1054 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){
1055         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1056 /*@SWIG@*/ self->Emit( arg1, arg2 );
1057       }
1058 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1059          return self->Empty();
1060       }
1061 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1062         return self->GetConnectionCount();
1063       }
1064 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1065           self->Connect( func );
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1068           self->Disconnect( func );
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1071           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1072 /*@SWIG@*/ self->Emit( arg );
1073       }
1074 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){
1075          return self->Empty();
1076       }
1077 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){
1078         return self->GetConnectionCount();
1079       }
1080 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)){
1081           return self->Connect( func );
1082       }
1083 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)){
1084           self->Disconnect( func );
1085       }
1086 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){
1087           self->Emit( arg1, arg3 );
1088       }
1089 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){
1090          return self->Empty();
1091       }
1092 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){
1093         return self->GetConnectionCount();
1094       }
1095 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)){
1096           return self->Connect( func );
1097       }
1098 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)){
1099           self->Disconnect( func );
1100       }
1101 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){
1102           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1103 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1104       }
1105
1106 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1107          return self->Empty();
1108       }
1109 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1110         return self->GetConnectionCount();
1111       }
1112 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1113           self->Connect( func );
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1116           self->Disconnect( func );
1117       }
1118 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1119           return self->Emit();
1120       }
1121
1122 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1123         std::vector< unsigned int >* pv = 0;
1124         if (capacity >= 0) {
1125           pv = new std::vector< unsigned int >();
1126           pv->reserve(capacity);
1127        } else {
1128           throw std::out_of_range("capacity");
1129        }
1130        return pv;
1131       }
1132 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1133         if (index>=0 && index<(int)self->size())
1134           return (*self)[index];
1135         else
1136           throw std::out_of_range("index");
1137       }
1138 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1139         if (index>=0 && index<(int)self->size())
1140           return (*self)[index];
1141         else
1142           throw std::out_of_range("index");
1143       }
1144 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1145         if (index>=0 && index<(int)self->size())
1146           (*self)[index] = val;
1147         else
1148           throw std::out_of_range("index");
1149       }
1150 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1151         self->insert(self->end(), values.begin(), values.end());
1152       }
1153 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1154         if (index < 0)
1155           throw std::out_of_range("index");
1156         if (count < 0)
1157           throw std::out_of_range("count");
1158         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1159           throw std::invalid_argument("invalid range");
1160         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1161       }
1162 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1163         if (index>=0 && index<(int)self->size()+1)
1164           self->insert(self->begin()+index, x);
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1169         if (index>=0 && index<(int)self->size()+1)
1170           self->insert(self->begin()+index, values.begin(), values.end());
1171         else
1172           throw std::out_of_range("index");
1173       }
1174 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1175         if (index>=0 && index<(int)self->size())
1176           self->erase(self->begin() + index);
1177         else
1178           throw std::out_of_range("index");
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1181         if (index < 0)
1182           throw std::out_of_range("index");
1183         if (count < 0)
1184           throw std::out_of_range("count");
1185         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1186           throw std::invalid_argument("invalid range");
1187         self->erase(self->begin()+index, self->begin()+index+count);
1188       }
1189 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1190         if (count < 0)
1191           throw std::out_of_range("count");
1192         return new std::vector< unsigned int >(count, value);
1193       }
1194 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1195         std::reverse(self->begin(), self->end());
1196       }
1197 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1198         if (index < 0)
1199           throw std::out_of_range("index");
1200         if (count < 0)
1201           throw std::out_of_range("count");
1202         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1203           throw std::invalid_argument("invalid range");
1204         std::reverse(self->begin()+index, self->begin()+index+count);
1205       }
1206 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1207         if (index < 0)
1208           throw std::out_of_range("index");
1209         if (index+values.size() > self->size())
1210           throw std::out_of_range("index");
1211         std::copy(values.begin(), values.end(), self->begin()+index);
1212       }
1213 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1214         return std::find(self->begin(), self->end(), value) != self->end();
1215       }
1216 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1217         int index = -1;
1218         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1219         if (it != self->end())
1220           index = (int)(it - self->begin());
1221         return index;
1222       }
1223 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1224         int index = -1;
1225         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1226         if (rit != self->rend())
1227           index = (int)(self->rend() - 1 - rit);
1228         return index;
1229       }
1230 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1231         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1232         if (it != self->end()) {
1233           self->erase(it);
1234           return true;
1235         }
1236         return false;
1237       }
1238 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){
1239         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1240         if (capacity >= 0) {
1241           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1242           pv->reserve(capacity);
1243        } else {
1244           throw std::out_of_range("capacity");
1245        }
1246        return pv;
1247       }
1248 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){
1249         if (index>=0 && index<(int)self->size())
1250           return (*self)[index];
1251         else
1252           throw std::out_of_range("index");
1253       }
1254 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){
1255         if (index>=0 && index<(int)self->size())
1256           return (*self)[index];
1257         else
1258           throw std::out_of_range("index");
1259       }
1260 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){
1261         if (index>=0 && index<(int)self->size())
1262           (*self)[index] = val;
1263         else
1264           throw std::out_of_range("index");
1265       }
1266 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){
1267         self->insert(self->end(), values.begin(), values.end());
1268       }
1269 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){
1270         if (index < 0)
1271           throw std::out_of_range("index");
1272         if (count < 0)
1273           throw std::out_of_range("count");
1274         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1275           throw std::invalid_argument("invalid range");
1276         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1277       }
1278 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){
1279         if (index>=0 && index<(int)self->size()+1)
1280           self->insert(self->begin()+index, x);
1281         else
1282           throw std::out_of_range("index");
1283       }
1284 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){
1285         if (index>=0 && index<(int)self->size()+1)
1286           self->insert(self->begin()+index, values.begin(), values.end());
1287         else
1288           throw std::out_of_range("index");
1289       }
1290 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){
1291         if (index>=0 && index<(int)self->size())
1292           self->erase(self->begin() + index);
1293         else
1294           throw std::out_of_range("index");
1295       }
1296 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){
1297         if (index < 0)
1298           throw std::out_of_range("index");
1299         if (count < 0)
1300           throw std::out_of_range("count");
1301         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1302           throw std::invalid_argument("invalid range");
1303         self->erase(self->begin()+index, self->begin()+index+count);
1304       }
1305 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){
1306         if (count < 0)
1307           throw std::out_of_range("count");
1308         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1309       }
1310 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){
1311         std::reverse(self->begin(), self->end());
1312       }
1313 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){
1314         if (index < 0)
1315           throw std::out_of_range("index");
1316         if (count < 0)
1317           throw std::out_of_range("count");
1318         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1319           throw std::invalid_argument("invalid range");
1320         std::reverse(self->begin()+index, self->begin()+index+count);
1321       }
1322 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){
1323         if (index < 0)
1324           throw std::out_of_range("index");
1325         if (index+values.size() > self->size())
1326           throw std::out_of_range("index");
1327         std::copy(values.begin(), values.end(), self->begin()+index);
1328       }
1329 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1330         std::vector< Dali::Actor >* pv = 0;
1331         if (capacity >= 0) {
1332           pv = new std::vector< Dali::Actor >();
1333           pv->reserve(capacity);
1334        } else {
1335           throw std::out_of_range("capacity");
1336        }
1337        return pv;
1338       }
1339 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1340         if (index>=0 && index<(int)self->size())
1341           return (*self)[index];
1342         else
1343           throw std::out_of_range("index");
1344       }
1345 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1346         if (index>=0 && index<(int)self->size())
1347           return (*self)[index];
1348         else
1349           throw std::out_of_range("index");
1350       }
1351 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1352         if (index>=0 && index<(int)self->size())
1353           (*self)[index] = val;
1354         else
1355           throw std::out_of_range("index");
1356       }
1357 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1358         self->insert(self->end(), values.begin(), values.end());
1359       }
1360 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1361         if (index < 0)
1362           throw std::out_of_range("index");
1363         if (count < 0)
1364           throw std::out_of_range("count");
1365         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1366           throw std::invalid_argument("invalid range");
1367         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1368       }
1369 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1370         if (index>=0 && index<(int)self->size()+1)
1371           self->insert(self->begin()+index, x);
1372         else
1373           throw std::out_of_range("index");
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1376         if (index>=0 && index<(int)self->size()+1)
1377           self->insert(self->begin()+index, values.begin(), values.end());
1378         else
1379           throw std::out_of_range("index");
1380       }
1381 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1382         if (index>=0 && index<(int)self->size())
1383           self->erase(self->begin() + index);
1384         else
1385           throw std::out_of_range("index");
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1388         if (index < 0)
1389           throw std::out_of_range("index");
1390         if (count < 0)
1391           throw std::out_of_range("count");
1392         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1393           throw std::invalid_argument("invalid range");
1394         self->erase(self->begin()+index, self->begin()+index+count);
1395       }
1396 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1397         if (count < 0)
1398           throw std::out_of_range("count");
1399         return new std::vector< Dali::Actor >(count, value);
1400       }
1401 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1402         std::reverse(self->begin(), self->end());
1403       }
1404 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1405         if (index < 0)
1406           throw std::out_of_range("index");
1407         if (count < 0)
1408           throw std::out_of_range("count");
1409         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1410           throw std::invalid_argument("invalid range");
1411         std::reverse(self->begin()+index, self->begin()+index+count);
1412       }
1413 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1414         if (index < 0)
1415           throw std::out_of_range("index");
1416         if (index+values.size() > self->size())
1417           throw std::out_of_range("index");
1418         std::copy(values.begin(), values.end(), self->begin()+index);
1419       }
1420 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1421          return self->Empty();
1422       }
1423 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1424         return self->GetConnectionCount();
1425       }
1426 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 &)){
1427           self->Connect( func );
1428       }
1429 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 &)){
1430           self->Disconnect( func );
1431       }
1432 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){
1433           return self->Emit( arg );
1434       }
1435 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){
1436          return self->Empty();
1437       }
1438 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){
1439         return self->GetConnectionCount();
1440       }
1441 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)){
1442         self->Connect( func );
1443       }
1444 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)){
1445         self->Disconnect( func );
1446       }
1447 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){
1448         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1449 /*@SWIG@*/ self->Emit( arg1, arg2 );
1450       }
1451 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1452          return self->Empty();
1453       }
1454 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){
1455         return self->GetConnectionCount();
1456       }
1457 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)){
1458         self->Connect( func );
1459       }
1460 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)){
1461         self->Disconnect( func );
1462       }
1463 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){
1464         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1465 /*@SWIG@*/ self->Emit( arg1, arg2 );
1466       }
1467 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1468          return self->Empty();
1469       }
1470 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1471         return self->GetConnectionCount();
1472       }
1473 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)){
1474         self->Connect( func );
1475       }
1476 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)){
1477         self->Disconnect( func );
1478       }
1479 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){
1480         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1481 /*@SWIG@*/ self->Emit( arg1, arg2 );
1482       }
1483 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){
1484          return self->Empty();
1485       }
1486 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){
1487         return self->GetConnectionCount();
1488       }
1489 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)){
1490         self->Connect( func );
1491       }
1492 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)){
1493         self->Disconnect( func );
1494       }
1495 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){
1496         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1497 /*@SWIG@*/ self->Emit( arg1, arg2 );
1498       }
1499 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1500          return self->Empty();
1501       }
1502 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1503         return self->GetConnectionCount();
1504       }
1505 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)){
1506           self->Connect( func );
1507       }
1508 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)){
1509           self->Disconnect( func );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1512           return self->Emit( arg );
1513       }
1514 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1515          return self->Empty();
1516       }
1517 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1518         return self->GetConnectionCount();
1519       }
1520 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)){
1521           self->Connect( func );
1522       }
1523 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)){
1524           self->Disconnect( func );
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1527           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1528 /*@SWIG@*/ self->Emit( arg );
1529       }
1530 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){
1531          return self->Empty();
1532       }
1533 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){
1534         return self->GetConnectionCount();
1535       }
1536 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)){
1537           return self->Connect( func );
1538       }
1539 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)){
1540           self->Disconnect( func );
1541       }
1542 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){
1543           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1544 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1545       }
1546 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1547          return self->Empty();
1548       }
1549 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1550         return self->GetConnectionCount();
1551       }
1552 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)){
1553           self->Connect( func );
1554       }
1555 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)){
1556           self->Disconnect( func );
1557       }
1558 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1559           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1560 /*@SWIG@*/ self->Emit( arg );
1561       }
1562 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){
1563          return self->Empty();
1564       }
1565 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){
1566         return self->GetConnectionCount();
1567       }
1568 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)){
1569           return self->Connect( func );
1570       }
1571 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)){
1572           self->Disconnect( func );
1573       }
1574 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){
1575           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1576 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1577       }
1578 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){
1579          return self->Empty();
1580       }
1581 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){
1582         return self->GetConnectionCount();
1583       }
1584 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 &)){
1585           self->Connect( func );
1586       }
1587 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 &)){
1588           self->Disconnect( func );
1589       }
1590 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){
1591           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1592 /*@SWIG@*/ self->Emit( arg );
1593       }
1594 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1595          return self->Empty();
1596       }
1597 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){
1598         return self->GetConnectionCount();
1599       }
1600 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 &)){
1601           self->Connect( func );
1602       }
1603 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 &)){
1604           self->Disconnect( func );
1605       }
1606 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){
1607           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1608 /*@SWIG@*/ self->Emit( arg );
1609       }
1610
1611
1612 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){
1613          return self->Empty();
1614       }
1615 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){
1616         return self->GetConnectionCount();
1617       }
1618 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 &)){
1619         self->Connect( func );
1620       }
1621 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 &)){
1622         self->Disconnect( func );
1623       }
1624 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){
1625         return self->Emit( arg1, arg2 );
1626       }
1627 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1628          return self->Empty();
1629       }
1630 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1631         return self->GetConnectionCount();
1632       }
1633 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)){
1634           self->Connect( func );
1635       }
1636 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)){
1637           self->Disconnect( func );
1638       }
1639 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1640           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1641 /*@SWIG@*/ self->Emit( arg );
1642       }
1643 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1644          return self->Empty();
1645       }
1646 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1647         return self->GetConnectionCount();
1648       }
1649 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 &)){
1650           self->Connect( func );
1651       }
1652 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 &)){
1653           self->Disconnect( func );
1654       }
1655 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){
1656           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1657 /*@SWIG@*/ self->Emit( arg );
1658       }
1659 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1660          return self->Empty();
1661       }
1662 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){
1663         return self->GetConnectionCount();
1664       }
1665 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)){
1666         self->Connect( func );
1667       }
1668 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)){
1669         self->Disconnect( func );
1670       }
1671 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){
1672         return self->Emit( arg1, arg2 );
1673       }
1674 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1675          return self->Empty();
1676       }
1677 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){
1678         return self->GetConnectionCount();
1679       }
1680 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)){
1681         self->Connect( func );
1682       }
1683 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)){
1684         self->Disconnect( func );
1685       }
1686 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){
1687         return self->Emit( arg1, arg2 );
1688       }
1689
1690 /* ---------------------------------------------------
1691  * C++ director class methods
1692  * --------------------------------------------------- */
1693
1694 #include "dali_wrap.h"
1695
1696 /*
1697  *  Widget director
1698  */
1699 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1700   swig_init_callbacks();
1701 }
1702
1703 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1704 }
1705
1706 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1707   char * jcontentInfo = 0 ;
1708   void * jwindow  ;
1709
1710   if (!swig_callbackOnCreate) {
1711     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1712     return;
1713   } else {
1714     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1715     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1716     swig_callbackOnCreate(jcontentInfo, jwindow);
1717   }
1718 }
1719
1720 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1721   char * jcontentInfo = 0 ;
1722   int jtype  ;
1723
1724   if (!swig_callbackOnTerminate) {
1725     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1726     return;
1727   } else {
1728     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1729     jtype = (int)type;
1730     swig_callbackOnTerminate(jcontentInfo, jtype);
1731   }
1732 }
1733
1734 void SwigDirector_WidgetImpl::OnPause() {
1735   if (!swig_callbackOnPause) {
1736     Dali::Internal::Adaptor::Widget::OnPause();
1737     return;
1738   } else {
1739     swig_callbackOnPause();
1740   }
1741 }
1742
1743 void SwigDirector_WidgetImpl::OnResume() {
1744   if (!swig_callbackOnResume) {
1745     Dali::Internal::Adaptor::Widget::OnResume();
1746     return;
1747   } else {
1748     swig_callbackOnResume();
1749   }
1750 }
1751
1752 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1753   void * jwindow  ;
1754
1755   if (!swig_callbackOnResize) {
1756     Dali::Internal::Adaptor::Widget::OnResize(window);
1757     return;
1758   } else {
1759     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1760     swig_callbackOnResize(jwindow);
1761   }
1762 }
1763
1764 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1765   char * jcontentInfo = 0 ;
1766   int jforce  ;
1767
1768   if (!swig_callbackOnUpdate) {
1769     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1770     return;
1771   } else {
1772     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1773     jforce = force;
1774     swig_callbackOnUpdate(jcontentInfo, jforce);
1775   }
1776 }
1777
1778 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1779   void * jslotObserver = 0 ;
1780   void * jcallback = 0 ;
1781
1782   if (!swig_callbackSignalConnected) {
1783     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1784     return;
1785   } else {
1786     jslotObserver = (void *) slotObserver;
1787     jcallback = (void *) callback;
1788     swig_callbackSignalConnected(jslotObserver, jcallback);
1789   }
1790 }
1791
1792 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1793   void * jslotObserver = 0 ;
1794   void * jcallback = 0 ;
1795
1796   if (!swig_callbackSignalDisconnected) {
1797     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1798     return;
1799   } else {
1800     jslotObserver = (void *) slotObserver;
1801     jcallback = (void *) callback;
1802     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1803   }
1804 }
1805
1806 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) {
1807
1808   swig_callbackOnCreate = callbackOnCreate;
1809   swig_callbackOnTerminate = callbackOnTerminate;
1810   swig_callbackOnPause = callbackOnPause;
1811   swig_callbackOnResume = callbackOnResume;
1812   swig_callbackOnResize = callbackOnResize;
1813   swig_callbackOnUpdate = callbackOnUpdate;
1814   swig_callbackSignalConnected = callbackSignalConnected;
1815   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1816 }
1817
1818 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1819   swig_callbackOnCreate = 0;
1820   swig_callbackOnTerminate = 0;
1821   swig_callbackOnPause = 0;
1822   swig_callbackOnResume = 0;
1823   swig_callbackOnResize = 0;
1824   swig_callbackOnUpdate = 0;
1825   swig_callbackSignalConnected = 0;
1826   swig_callbackSignalDisconnected = 0;
1827 }
1828
1829
1830 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1831   swig_init_callbacks();
1832 }
1833
1834 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1835
1836 }
1837
1838
1839 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1840   int jdepth  ;
1841
1842   if (!swig_callbackOnStageConnection) {
1843     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1844     return;
1845   } else {
1846     jdepth = depth;
1847     swig_callbackOnStageConnection(jdepth);
1848   }
1849 }
1850
1851 void SwigDirector_ViewImpl::OnStageDisconnection() {
1852   if (!swig_callbackOnStageDisconnection) {
1853     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1854     return;
1855   } else {
1856     swig_callbackOnStageDisconnection();
1857   }
1858 }
1859
1860 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1861   void * jchild = 0 ;
1862
1863   if (!swig_callbackOnChildAdd) {
1864     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1865     return;
1866   } else {
1867     jchild = (Dali::Actor *) &child;
1868     swig_callbackOnChildAdd(jchild);
1869   }
1870 }
1871
1872 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1873   void * jchild = 0 ;
1874
1875   if (!swig_callbackOnChildRemove) {
1876     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1877     return;
1878   } else {
1879     jchild = (Dali::Actor *) &child;
1880     swig_callbackOnChildRemove(jchild);
1881   }
1882 }
1883
1884 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1885   int jindex  ;
1886   void * jpropertyValue  ;
1887
1888   if (!swig_callbackOnPropertySet) {
1889     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1890     return;
1891   } else {
1892     jindex = index;
1893     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1894     swig_callbackOnPropertySet(jindex, jpropertyValue);
1895   }
1896 }
1897
1898 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1899   void * jtargetSize = 0 ;
1900
1901   if (!swig_callbackOnSizeSet) {
1902     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1903     return;
1904   } else {
1905     jtargetSize = (Dali::Vector3 *) &targetSize;
1906     swig_callbackOnSizeSet(jtargetSize);
1907   }
1908 }
1909
1910 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1911   void * janimation = 0 ;
1912   void * jtargetSize = 0 ;
1913
1914   if (!swig_callbackOnSizeAnimation) {
1915     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1916     return;
1917   } else {
1918     janimation = (Dali::Animation *) &animation;
1919     jtargetSize = (Dali::Vector3 *) &targetSize;
1920     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1921   }
1922 }
1923
1924 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1925   bool c_result = SwigValueInit< bool >() ;
1926   unsigned int jresult = 0 ;
1927   void * jarg0 = 0 ;
1928
1929   if (!swig_callbackOnTouchEvent) {
1930     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1931   } else {
1932     jarg0 = (Dali::TouchEvent *) &event;
1933     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1934     c_result = jresult ? true : false;
1935   }
1936   return c_result;
1937 }
1938
1939 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1940   bool c_result = SwigValueInit< bool >() ;
1941   unsigned int jresult = 0 ;
1942   void * jarg0 = 0 ;
1943
1944   if (!swig_callbackOnHoverEvent) {
1945     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1946   } else {
1947     jarg0 = (Dali::HoverEvent *) &event;
1948     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1949     c_result = jresult ? true : false;
1950   }
1951   return c_result;
1952 }
1953
1954 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1955   bool c_result = SwigValueInit< bool >() ;
1956   unsigned int jresult = 0 ;
1957   void * jarg0 = 0 ;
1958
1959   if (!swig_callbackOnKeyEvent) {
1960     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1961   } else {
1962     jarg0 = (Dali::KeyEvent *) &event;
1963     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1964     c_result = jresult ? true : false;
1965   }
1966   return c_result;
1967 }
1968
1969 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1970   bool c_result = SwigValueInit< bool >() ;
1971   unsigned int jresult = 0 ;
1972   void * jarg0 = 0 ;
1973
1974   if (!swig_callbackOnWheelEvent) {
1975     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1976   } else {
1977     jarg0 = (Dali::WheelEvent *) &event;
1978     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1979     c_result = jresult ? true : false;
1980   }
1981   return c_result;
1982 }
1983
1984 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1985   void * jsize = 0 ;
1986   void * jcontainer = 0 ;
1987
1988   if (!swig_callbackOnRelayout) {
1989     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1990     return;
1991   } else {
1992     jsize = (Dali::Vector2 *) &size;
1993     jcontainer = (Dali::RelayoutContainer *) &container;
1994     swig_callbackOnRelayout(jsize, jcontainer);
1995   }
1996 }
1997
1998 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1999   int jpolicy  ;
2000   int jdimension  ;
2001
2002   if (!swig_callbackOnSetResizePolicy) {
2003     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2004     return;
2005   } else {
2006     jpolicy = (int)policy;
2007     jdimension = (int)dimension;
2008     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2009   }
2010 }
2011
2012 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2013   Dali::Vector3 c_result ;
2014   void * jresult = 0 ;
2015
2016   if (!swig_callbackGetNaturalSize) {
2017     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2018   } else {
2019     jresult = (void *) swig_callbackGetNaturalSize();
2020     if (!jresult) {
2021       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2022       return c_result;
2023     }
2024     c_result = *(Dali::Vector3 *)jresult;
2025   }
2026   return c_result;
2027 }
2028
2029 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2030   float c_result = SwigValueInit< float >() ;
2031   float jresult = 0 ;
2032   void * jchild = 0 ;
2033   int jdimension  ;
2034
2035   if (!swig_callbackCalculateChildSize) {
2036     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2037   } else {
2038     jchild = (Dali::Actor *) &child;
2039     jdimension = (int)dimension;
2040     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2041     c_result = (float)jresult;
2042   }
2043   return c_result;
2044 }
2045
2046 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2047   float c_result = SwigValueInit< float >() ;
2048   float jresult = 0 ;
2049   float jwidth  ;
2050
2051   if (!swig_callbackGetHeightForWidth) {
2052     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2053   } else {
2054     jwidth = width;
2055     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2056     c_result = (float)jresult;
2057   }
2058   return c_result;
2059 }
2060
2061 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2062   float c_result = SwigValueInit< float >() ;
2063   float jresult = 0 ;
2064   float jheight  ;
2065
2066   if (!swig_callbackGetWidthForHeight) {
2067     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2068   } else {
2069     jheight = height;
2070     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2071     c_result = (float)jresult;
2072   }
2073   return c_result;
2074 }
2075
2076 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2077   bool c_result = SwigValueInit< bool >() ;
2078   unsigned int jresult = 0 ;
2079   int jdimension  ;
2080
2081   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2082     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2083   } else {
2084     jdimension = (int)dimension;
2085     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2086     c_result = jresult ? true : false;
2087   }
2088   return c_result;
2089 }
2090
2091 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2092   int jdimension  ;
2093
2094   if (!swig_callbackOnCalculateRelayoutSize) {
2095     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2096     return;
2097   } else {
2098     jdimension = (int)dimension;
2099     swig_callbackOnCalculateRelayoutSize(jdimension);
2100   }
2101 }
2102
2103 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2104   float jsize  ;
2105   int jdimension  ;
2106
2107   if (!swig_callbackOnLayoutNegotiated) {
2108     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2109     return;
2110   } else {
2111     jsize = size;
2112     jdimension = (int)dimension;
2113     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2114   }
2115 }
2116
2117 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2118   return Dali::CustomActorImpl::GetExtension();
2119 }
2120
2121 void SwigDirector_ViewImpl::OnInitialize() {
2122   if (!swig_callbackOnInitialize) {
2123     Dali::Toolkit::Internal::Control::OnInitialize();
2124     return;
2125   } else {
2126     swig_callbackOnInitialize();
2127   }
2128 }
2129
2130 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2131   void * jchild = 0 ;
2132
2133   if (!swig_callbackOnControlChildAdd) {
2134     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2135     return;
2136   } else {
2137     jchild = (Dali::Actor *) &child;
2138     swig_callbackOnControlChildAdd(jchild);
2139   }
2140 }
2141
2142 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2143   void * jchild = 0 ;
2144
2145   if (!swig_callbackOnControlChildRemove) {
2146     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2147     return;
2148   } else {
2149     jchild = (Dali::Actor *) &child;
2150     swig_callbackOnControlChildRemove(jchild);
2151   }
2152 }
2153
2154 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2155   void * jstyleManager  ;
2156   int jchange  ;
2157
2158   if (!swig_callbackOnStyleChange) {
2159     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2160     return;
2161   } else {
2162     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2163     jchange = (int)change;
2164     swig_callbackOnStyleChange(jstyleManager, jchange);
2165   }
2166 }
2167
2168 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2169   bool c_result = SwigValueInit< bool >() ;
2170   unsigned int jresult = 0 ;
2171
2172   if (!swig_callbackOnAccessibilityActivated) {
2173     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2174   } else {
2175     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2176     c_result = jresult ? true : false;
2177   }
2178   return c_result;
2179 }
2180
2181 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2182   bool c_result = SwigValueInit< bool >() ;
2183   unsigned int jresult = 0 ;
2184   void * jgesture  ;
2185
2186   if (!swig_callbackOnAccessibilityPan) {
2187     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2188   } else {
2189     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2190     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2191     c_result = jresult ? true : false;
2192   }
2193   return c_result;
2194 }
2195
2196 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2197   bool c_result = SwigValueInit< bool >() ;
2198   unsigned int jresult = 0 ;
2199   void * jtouchEvent = 0 ;
2200
2201   if (!swig_callbackOnAccessibilityTouch) {
2202     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2203   } else {
2204     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2205     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2206     c_result = jresult ? true : false;
2207   }
2208   return c_result;
2209 }
2210
2211 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2212   bool c_result = SwigValueInit< bool >() ;
2213   unsigned int jresult = 0 ;
2214   unsigned int jisIncrease  ;
2215
2216   if (!swig_callbackOnAccessibilityValueChange) {
2217     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2218   } else {
2219     jisIncrease = isIncrease;
2220     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2221     c_result = jresult ? true : false;
2222   }
2223   return c_result;
2224 }
2225
2226 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2227   bool c_result = SwigValueInit< bool >() ;
2228   unsigned int jresult = 0 ;
2229
2230   if (!swig_callbackOnAccessibilityZoom) {
2231     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2232   } else {
2233     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2234     c_result = jresult ? true : false;
2235   }
2236   return c_result;
2237 }
2238
2239 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2240   if (!swig_callbackOnKeyInputFocusGained) {
2241     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2242     return;
2243   } else {
2244     swig_callbackOnKeyInputFocusGained();
2245   }
2246 }
2247
2248 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2249   if (!swig_callbackOnKeyInputFocusLost) {
2250     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2251     return;
2252   } else {
2253     swig_callbackOnKeyInputFocusLost();
2254   }
2255 }
2256
2257 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2258   Dali::Actor c_result ;
2259   void * jresult = 0 ;
2260   void * jcurrentFocusedActor  ;
2261   int jdirection  ;
2262   unsigned int jloopEnabled  ;
2263
2264   if (!swig_callbackGetNextKeyboardFocusableActor) {
2265     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2266   } else {
2267     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2268     jdirection = (int)direction;
2269     jloopEnabled = loopEnabled;
2270     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2271     if (!jresult) {
2272       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2273       return c_result;
2274     }
2275     c_result = *(Dali::Actor *)jresult;
2276   }
2277   return c_result;
2278 }
2279
2280 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2281   void * jcommitedFocusableActor  ;
2282
2283   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2284     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2285     return;
2286   } else {
2287     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2288     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2289   }
2290 }
2291
2292 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2293   bool c_result = SwigValueInit< bool >() ;
2294   unsigned int jresult = 0 ;
2295
2296   if (!swig_callbackOnKeyboardEnter) {
2297     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2298   } else {
2299     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2300     c_result = jresult ? true : false;
2301   }
2302   return c_result;
2303 }
2304
2305 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2306   void * jpinch = 0 ;
2307
2308   if (!swig_callbackOnPinch) {
2309     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2310     return;
2311   } else {
2312     jpinch = (Dali::PinchGesture *) &pinch;
2313     swig_callbackOnPinch(jpinch);
2314   }
2315 }
2316
2317 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2318   void * jpan = 0 ;
2319
2320   if (!swig_callbackOnPan) {
2321     Dali::Toolkit::Internal::Control::OnPan(pan);
2322     return;
2323   } else {
2324     jpan = (Dali::PanGesture *) &pan;
2325     swig_callbackOnPan(jpan);
2326   }
2327 }
2328
2329 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2330   void * jtap = 0 ;
2331
2332   if (!swig_callbackOnTap) {
2333     Dali::Toolkit::Internal::Control::OnTap(tap);
2334     return;
2335   } else {
2336     jtap = (Dali::TapGesture *) &tap;
2337     swig_callbackOnTap(jtap);
2338   }
2339 }
2340
2341 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2342   void * jlongPress = 0 ;
2343
2344   if (!swig_callbackOnLongPress) {
2345     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2346     return;
2347   } else {
2348     jlongPress = (Dali::LongPressGesture *) &longPress;
2349     swig_callbackOnLongPress(jlongPress);
2350   }
2351 }
2352
2353 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2354   void * jslotObserver = 0 ;
2355   void * jcallback = 0 ;
2356
2357   if (!swig_callbackSignalConnected) {
2358     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2359     return;
2360   } else {
2361     jslotObserver = (void *) slotObserver;
2362     jcallback = (void *) callback;
2363     swig_callbackSignalConnected(jslotObserver, jcallback);
2364   }
2365 }
2366
2367 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2368   void * jslotObserver = 0 ;
2369   void * jcallback = 0 ;
2370
2371   if (!swig_callbackSignalDisconnected) {
2372     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2373     return;
2374   } else {
2375     jslotObserver = (void *) slotObserver;
2376     jcallback = (void *) callback;
2377     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2378   }
2379 }
2380
2381 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2382   return Dali::Toolkit::Internal::Control::GetControlExtension();
2383 }
2384
2385 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) {
2386   swig_callbackOnStageConnection = callbackOnStageConnection;
2387   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2388   swig_callbackOnChildAdd = callbackOnChildAdd;
2389   swig_callbackOnChildRemove = callbackOnChildRemove;
2390   swig_callbackOnPropertySet = callbackOnPropertySet;
2391   swig_callbackOnSizeSet = callbackOnSizeSet;
2392   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2393   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2394   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2395   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2396   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2397   swig_callbackOnRelayout = callbackOnRelayout;
2398   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2399   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2400   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2401   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2402   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2403   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2404   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2405   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2406   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2407   swig_callbackOnInitialize = callbackOnInitialize;
2408   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2409   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2410   swig_callbackOnStyleChange = callbackOnStyleChange;
2411   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2412   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2413   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2414   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2415   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2416   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2417   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2418   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2419   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2420   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2421   swig_callbackOnPinch = callbackOnPinch;
2422   swig_callbackOnPan = callbackOnPan;
2423   swig_callbackOnTap = callbackOnTap;
2424   swig_callbackOnLongPress = callbackOnLongPress;
2425   swig_callbackSignalConnected = callbackSignalConnected;
2426   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2427 }
2428
2429 void SwigDirector_ViewImpl::swig_init_callbacks() {
2430   swig_callbackOnStageConnection = 0;
2431   swig_callbackOnStageDisconnection = 0;
2432   swig_callbackOnChildAdd = 0;
2433   swig_callbackOnChildRemove = 0;
2434   swig_callbackOnPropertySet = 0;
2435   swig_callbackOnSizeSet = 0;
2436   swig_callbackOnSizeAnimation = 0;
2437   swig_callbackOnTouchEvent = 0;
2438   swig_callbackOnHoverEvent = 0;
2439   swig_callbackOnKeyEvent = 0;
2440   swig_callbackOnWheelEvent = 0;
2441   swig_callbackOnRelayout = 0;
2442   swig_callbackOnSetResizePolicy = 0;
2443   swig_callbackGetNaturalSize = 0;
2444   swig_callbackCalculateChildSize = 0;
2445   swig_callbackGetHeightForWidth = 0;
2446   swig_callbackGetWidthForHeight = 0;
2447   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2448   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2449   swig_callbackOnCalculateRelayoutSize = 0;
2450   swig_callbackOnLayoutNegotiated = 0;
2451   swig_callbackOnInitialize = 0;
2452   swig_callbackOnControlChildAdd = 0;
2453   swig_callbackOnControlChildRemove = 0;
2454   swig_callbackOnStyleChange = 0;
2455   swig_callbackOnAccessibilityActivated = 0;
2456   swig_callbackOnAccessibilityPan = 0;
2457   swig_callbackOnAccessibilityTouch = 0;
2458   swig_callbackOnAccessibilityValueChange = 0;
2459   swig_callbackOnAccessibilityZoom = 0;
2460   swig_callbackOnKeyInputFocusGained = 0;
2461   swig_callbackOnKeyInputFocusLost = 0;
2462   swig_callbackGetNextKeyboardFocusableActor = 0;
2463   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2464   swig_callbackOnKeyboardEnter = 0;
2465   swig_callbackOnPinch = 0;
2466   swig_callbackOnPan = 0;
2467   swig_callbackOnTap = 0;
2468   swig_callbackOnLongPress = 0;
2469   swig_callbackSignalConnected = 0;
2470   swig_callbackSignalDisconnected = 0;
2471 }
2472
2473 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2474   swig_init_callbacks();
2475 }
2476
2477 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2478
2479 }
2480
2481
2482 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2483   unsigned int c_result = SwigValueInit< unsigned int >() ;
2484   unsigned int jresult = 0 ;
2485
2486   if (!swig_callbackGetNumberOfItems) {
2487     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2488   } else {
2489     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2490     c_result = (unsigned int)jresult;
2491   }
2492   return c_result;
2493 }
2494
2495 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2496   Dali::Actor c_result ;
2497   void * jresult = 0 ;
2498   unsigned int jitemId  ;
2499
2500   if (!swig_callbackNewItem) {
2501     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2502   } else {
2503     jitemId = itemId;
2504     jresult = (void *) swig_callbackNewItem(jitemId);
2505     if (!jresult) {
2506       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2507       return c_result;
2508     }
2509     c_result = *(Dali::Actor *)jresult;
2510   }
2511   return c_result;
2512 }
2513
2514 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2515   unsigned int jitemId  ;
2516   void * jactor  ;
2517
2518   if (!swig_callbackItemReleased) {
2519     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2520     return;
2521   } else {
2522     jitemId = itemId;
2523     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2524     swig_callbackItemReleased(jitemId, jactor);
2525   }
2526 }
2527
2528 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2529   return Dali::Toolkit::ItemFactory::GetExtension();
2530 }
2531
2532 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2533   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2534   swig_callbackNewItem = callbackNewItem;
2535   swig_callbackItemReleased = callbackItemReleased;
2536 }
2537
2538 void SwigDirector_ItemFactory::swig_init_callbacks() {
2539   swig_callbackGetNumberOfItems = 0;
2540   swig_callbackNewItem = 0;
2541   swig_callbackItemReleased = 0;
2542 }
2543
2544 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2545   swig_init_callbacks();
2546 }
2547
2548 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2549
2550 }
2551
2552
2553 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2554   Dali::Actor c_result ;
2555   void * jresult = 0 ;
2556   void * jcurrent  ;
2557   void * jproposed  ;
2558   int jdirection  ;
2559
2560   if (!swig_callbackGetNextFocusableActor) {
2561     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2562   } else {
2563     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2564     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2565     jdirection = (int)direction;
2566     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2567     if (!jresult) {
2568       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2569       return c_result;
2570     }
2571     c_result = *(Dali::Actor *)jresult;
2572   }
2573   return c_result;
2574 }
2575
2576 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2577   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2578 }
2579
2580 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2581   swig_callbackGetNextFocusableActor = 0;
2582 }
2583
2584
2585 #ifdef __cplusplus
2586 extern "C" {
2587 #endif
2588
2589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2590   void * jresult ;
2591   floatp *result = 0 ;
2592
2593   {
2594     try {
2595       result = (floatp *)new_floatp();
2596     } catch (std::out_of_range& e) {
2597       {
2598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2599       };
2600     } catch (std::exception& e) {
2601       {
2602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2603       };
2604     } catch (DaliException e) {
2605       {
2606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2607       };
2608     } catch (...) {
2609       {
2610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2611       };
2612     }
2613   }
2614   jresult = (void *)result;
2615   return jresult;
2616 }
2617
2618
2619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2620   floatp *arg1 = (floatp *) 0 ;
2621
2622   arg1 = (floatp *)jarg1;
2623   {
2624     try {
2625       delete_floatp(arg1);
2626     } catch (std::out_of_range& e) {
2627       {
2628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2629       };
2630     } catch (std::exception& e) {
2631       {
2632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2633       };
2634     } catch (Dali::DaliException e) {
2635       {
2636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2637       };
2638     } catch (...) {
2639       {
2640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2641       };
2642     }
2643   }
2644
2645 }
2646
2647
2648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2649   floatp *arg1 = (floatp *) 0 ;
2650   float arg2 ;
2651
2652   arg1 = (floatp *)jarg1;
2653   arg2 = (float)jarg2;
2654   {
2655     try {
2656       floatp_assign(arg1,arg2);
2657     } catch (std::out_of_range& e) {
2658       {
2659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2660       };
2661     } catch (std::exception& e) {
2662       {
2663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2664       };
2665     } catch (Dali::DaliException e) {
2666       {
2667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2668       };
2669     } catch (...) {
2670       {
2671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2672       };
2673     }
2674   }
2675
2676 }
2677
2678
2679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2680   float jresult ;
2681   floatp *arg1 = (floatp *) 0 ;
2682   float result;
2683
2684   arg1 = (floatp *)jarg1;
2685   {
2686     try {
2687       result = (float)floatp_value(arg1);
2688     } catch (std::out_of_range& e) {
2689       {
2690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2691       };
2692     } catch (std::exception& e) {
2693       {
2694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2695       };
2696     } catch (DaliException e) {
2697       {
2698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2699       };
2700     } catch (...) {
2701       {
2702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2703       };
2704     }
2705   }
2706   jresult = result;
2707   return jresult;
2708 }
2709
2710
2711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2712   void * jresult ;
2713   floatp *arg1 = (floatp *) 0 ;
2714   float *result = 0 ;
2715
2716   arg1 = (floatp *)jarg1;
2717   {
2718     try {
2719       result = (float *)floatp_cast(arg1);
2720     } catch (std::out_of_range& e) {
2721       {
2722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2723       };
2724     } catch (std::exception& e) {
2725       {
2726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2727       };
2728     } catch (Dali::DaliException e) {
2729       {
2730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2731       };
2732     } catch (...) {
2733       {
2734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2735       };
2736     }
2737   }
2738
2739   jresult = (void *)result;
2740   return jresult;
2741 }
2742
2743
2744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2745   void * jresult ;
2746   float *arg1 = (float *) 0 ;
2747   floatp *result = 0 ;
2748
2749   arg1 = (float *)jarg1;
2750   {
2751     try {
2752       result = (floatp *)floatp_frompointer(arg1);
2753     } catch (std::out_of_range& e) {
2754       {
2755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2756       };
2757     } catch (std::exception& e) {
2758       {
2759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2760       };
2761     } catch (Dali::DaliException e) {
2762       {
2763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2764       };
2765     } catch (...) {
2766       {
2767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2768       };
2769     }
2770   }
2771
2772   jresult = (void *)result;
2773   return jresult;
2774 }
2775
2776
2777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2778   void * jresult ;
2779   intp *result = 0 ;
2780
2781   {
2782     try {
2783       result = (intp *)new_intp();
2784     } catch (std::out_of_range& e) {
2785       {
2786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2787       };
2788     } catch (std::exception& e) {
2789       {
2790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2791       };
2792     } catch (Dali::DaliException e) {
2793       {
2794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2795       };
2796     } catch (...) {
2797       {
2798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2799       };
2800     }
2801   }
2802
2803   jresult = (void *)result;
2804   return jresult;
2805 }
2806
2807
2808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2809   intp *arg1 = (intp *) 0 ;
2810
2811   arg1 = (intp *)jarg1;
2812   {
2813     try {
2814       delete_intp(arg1);
2815     } catch (std::out_of_range& e) {
2816       {
2817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2818       };
2819     } catch (std::exception& e) {
2820       {
2821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2822       };
2823     } catch (Dali::DaliException e) {
2824       {
2825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2826       };
2827     } catch (...) {
2828       {
2829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2830       };
2831     }
2832   }
2833
2834 }
2835
2836
2837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2838   intp *arg1 = (intp *) 0 ;
2839   int arg2 ;
2840
2841   arg1 = (intp *)jarg1;
2842   arg2 = (int)jarg2;
2843   {
2844     try {
2845       intp_assign(arg1,arg2);
2846     } catch (std::out_of_range& e) {
2847       {
2848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2849       };
2850     } catch (std::exception& e) {
2851       {
2852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2853       };
2854     } catch (Dali::DaliException e) {
2855       {
2856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2857       };
2858     } catch (...) {
2859       {
2860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2861       };
2862     }
2863   }
2864
2865 }
2866
2867
2868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2869   int jresult ;
2870   intp *arg1 = (intp *) 0 ;
2871   int result;
2872
2873   arg1 = (intp *)jarg1;
2874   {
2875     try {
2876       result = (int)intp_value(arg1);
2877     } catch (std::out_of_range& e) {
2878       {
2879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2880       };
2881     } catch (std::exception& e) {
2882       {
2883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2884       };
2885     } catch (Dali::DaliException e) {
2886       {
2887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2888       };
2889     } catch (...) {
2890       {
2891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2892       };
2893     }
2894   }
2895
2896   jresult = result;
2897   return jresult;
2898 }
2899
2900
2901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2902   void * jresult ;
2903   intp *arg1 = (intp *) 0 ;
2904   int *result = 0 ;
2905
2906   arg1 = (intp *)jarg1;
2907   {
2908     try {
2909       result = (int *)intp_cast(arg1);
2910     } catch (std::out_of_range& e) {
2911       {
2912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2913       };
2914     } catch (std::exception& e) {
2915       {
2916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2917       };
2918     } catch (Dali::DaliException e) {
2919       {
2920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2921       };
2922     } catch (...) {
2923       {
2924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2925       };
2926     }
2927   }
2928
2929   jresult = (void *)result;
2930   return jresult;
2931 }
2932
2933
2934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2935   void * jresult ;
2936   int *arg1 = (int *) 0 ;
2937   intp *result = 0 ;
2938
2939   arg1 = (int *)jarg1;
2940   {
2941     try {
2942       result = (intp *)intp_frompointer(arg1);
2943     } catch (std::out_of_range& e) {
2944       {
2945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2946       };
2947     } catch (std::exception& e) {
2948       {
2949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2950       };
2951     } catch (Dali::DaliException e) {
2952       {
2953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2954       };
2955     } catch (...) {
2956       {
2957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2958       };
2959     }
2960   }
2961
2962   jresult = (void *)result;
2963   return jresult;
2964 }
2965
2966
2967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2968   void * jresult ;
2969   doublep *result = 0 ;
2970
2971   {
2972     try {
2973       result = (doublep *)new_doublep();
2974     } catch (std::out_of_range& e) {
2975       {
2976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2977       };
2978     } catch (std::exception& e) {
2979       {
2980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2981       };
2982     } catch (Dali::DaliException e) {
2983       {
2984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2985       };
2986     } catch (...) {
2987       {
2988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2989       };
2990     }
2991   }
2992
2993   jresult = (void *)result;
2994   return jresult;
2995 }
2996
2997
2998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2999   doublep *arg1 = (doublep *) 0 ;
3000
3001   arg1 = (doublep *)jarg1;
3002   {
3003     try {
3004       delete_doublep(arg1);
3005     } catch (std::out_of_range& e) {
3006       {
3007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3008       };
3009     } catch (std::exception& e) {
3010       {
3011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3012       };
3013     } catch (Dali::DaliException e) {
3014       {
3015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3016       };
3017     } catch (...) {
3018       {
3019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3020       };
3021     }
3022   }
3023
3024 }
3025
3026
3027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3028   doublep *arg1 = (doublep *) 0 ;
3029   double arg2 ;
3030
3031   arg1 = (doublep *)jarg1;
3032   arg2 = (double)jarg2;
3033   {
3034     try {
3035       doublep_assign(arg1,arg2);
3036     } catch (std::out_of_range& e) {
3037       {
3038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3039       };
3040     } catch (std::exception& e) {
3041       {
3042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3043       };
3044     } catch (Dali::DaliException e) {
3045       {
3046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3047       };
3048     } catch (...) {
3049       {
3050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3051       };
3052     }
3053   }
3054
3055 }
3056
3057
3058 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3059   double jresult ;
3060   doublep *arg1 = (doublep *) 0 ;
3061   double result;
3062
3063   arg1 = (doublep *)jarg1;
3064   {
3065     try {
3066       result = (double)doublep_value(arg1);
3067     } catch (std::out_of_range& e) {
3068       {
3069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3070       };
3071     } catch (std::exception& e) {
3072       {
3073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3074       };
3075     } catch (Dali::DaliException e) {
3076       {
3077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3078       };
3079     } catch (...) {
3080       {
3081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3082       };
3083     }
3084   }
3085
3086   jresult = result;
3087   return jresult;
3088 }
3089
3090
3091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3092   void * jresult ;
3093   doublep *arg1 = (doublep *) 0 ;
3094   double *result = 0 ;
3095
3096   arg1 = (doublep *)jarg1;
3097   {
3098     try {
3099       result = (double *)doublep_cast(arg1);
3100     } catch (std::out_of_range& e) {
3101       {
3102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3103       };
3104     } catch (std::exception& e) {
3105       {
3106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3107       };
3108     } catch (Dali::DaliException e) {
3109       {
3110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3111       };
3112     } catch (...) {
3113       {
3114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3115       };
3116     }
3117   }
3118
3119   jresult = (void *)result;
3120   return jresult;
3121 }
3122
3123
3124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3125   void * jresult ;
3126   double *arg1 = (double *) 0 ;
3127   doublep *result = 0 ;
3128
3129   arg1 = (double *)jarg1;
3130   {
3131     try {
3132       result = (doublep *)doublep_frompointer(arg1);
3133     } catch (std::out_of_range& e) {
3134       {
3135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3136       };
3137     } catch (std::exception& e) {
3138       {
3139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3140       };
3141     } catch (Dali::DaliException e) {
3142       {
3143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3144       };
3145     } catch (...) {
3146       {
3147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3148       };
3149     }
3150   }
3151
3152   jresult = (void *)result;
3153   return jresult;
3154 }
3155
3156
3157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3158   void * jresult ;
3159   uintp *result = 0 ;
3160
3161   {
3162     try {
3163       result = (uintp *)new_uintp();
3164     } catch (std::out_of_range& e) {
3165       {
3166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3167       };
3168     } catch (std::exception& e) {
3169       {
3170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3171       };
3172     } catch (Dali::DaliException e) {
3173       {
3174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3175       };
3176     } catch (...) {
3177       {
3178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3179       };
3180     }
3181   }
3182
3183   jresult = (void *)result;
3184   return jresult;
3185 }
3186
3187
3188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3189   uintp *arg1 = (uintp *) 0 ;
3190
3191   arg1 = (uintp *)jarg1;
3192   {
3193     try {
3194       delete_uintp(arg1);
3195     } catch (std::out_of_range& e) {
3196       {
3197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3198       };
3199     } catch (std::exception& e) {
3200       {
3201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3202       };
3203     } catch (Dali::DaliException e) {
3204       {
3205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3206       };
3207     } catch (...) {
3208       {
3209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3210       };
3211     }
3212   }
3213
3214 }
3215
3216
3217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3218   uintp *arg1 = (uintp *) 0 ;
3219   unsigned int arg2 ;
3220
3221   arg1 = (uintp *)jarg1;
3222   arg2 = (unsigned int)jarg2;
3223   {
3224     try {
3225       uintp_assign(arg1,arg2);
3226     } catch (std::out_of_range& e) {
3227       {
3228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3229       };
3230     } catch (std::exception& e) {
3231       {
3232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3233       };
3234     } catch (Dali::DaliException e) {
3235       {
3236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3237       };
3238     } catch (...) {
3239       {
3240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3241       };
3242     }
3243   }
3244
3245 }
3246
3247
3248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3249   unsigned int jresult ;
3250   uintp *arg1 = (uintp *) 0 ;
3251   unsigned int result;
3252
3253   arg1 = (uintp *)jarg1;
3254   {
3255     try {
3256       result = (unsigned int)uintp_value(arg1);
3257     } catch (std::out_of_range& e) {
3258       {
3259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3260       };
3261     } catch (std::exception& e) {
3262       {
3263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3264       };
3265     } catch (Dali::DaliException e) {
3266       {
3267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3268       };
3269     } catch (...) {
3270       {
3271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3272       };
3273     }
3274   }
3275
3276   jresult = result;
3277   return jresult;
3278 }
3279
3280
3281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3282   void * jresult ;
3283   uintp *arg1 = (uintp *) 0 ;
3284   unsigned int *result = 0 ;
3285
3286   arg1 = (uintp *)jarg1;
3287   {
3288     try {
3289       result = (unsigned int *)uintp_cast(arg1);
3290     } catch (std::out_of_range& e) {
3291       {
3292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3293       };
3294     } catch (std::exception& e) {
3295       {
3296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3297       };
3298     } catch (Dali::DaliException e) {
3299       {
3300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3301       };
3302     } catch (...) {
3303       {
3304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3305       };
3306     }
3307   }
3308
3309   jresult = (void *)result;
3310   return jresult;
3311 }
3312
3313
3314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3315   void * jresult ;
3316   unsigned int *arg1 = (unsigned int *) 0 ;
3317   uintp *result = 0 ;
3318
3319   arg1 = (unsigned int *)jarg1;
3320   {
3321     try {
3322       result = (uintp *)uintp_frompointer(arg1);
3323     } catch (std::out_of_range& e) {
3324       {
3325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3326       };
3327     } catch (std::exception& e) {
3328       {
3329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3330       };
3331     } catch (Dali::DaliException e) {
3332       {
3333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3334       };
3335     } catch (...) {
3336       {
3337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3338       };
3339     }
3340   }
3341
3342   jresult = (void *)result;
3343   return jresult;
3344 }
3345
3346
3347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3348   void * jresult ;
3349   ushortp *result = 0 ;
3350
3351   {
3352     try {
3353       result = (ushortp *)new_ushortp();
3354     } catch (std::out_of_range& e) {
3355       {
3356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3357       };
3358     } catch (std::exception& e) {
3359       {
3360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3361       };
3362     } catch (Dali::DaliException e) {
3363       {
3364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3365       };
3366     } catch (...) {
3367       {
3368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3369       };
3370     }
3371   }
3372
3373   jresult = (void *)result;
3374   return jresult;
3375 }
3376
3377
3378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3379   ushortp *arg1 = (ushortp *) 0 ;
3380
3381   arg1 = (ushortp *)jarg1;
3382   {
3383     try {
3384       delete_ushortp(arg1);
3385     } catch (std::out_of_range& e) {
3386       {
3387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3388       };
3389     } catch (std::exception& e) {
3390       {
3391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3392       };
3393     } catch (Dali::DaliException e) {
3394       {
3395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3396       };
3397     } catch (...) {
3398       {
3399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3400       };
3401     }
3402   }
3403
3404 }
3405
3406
3407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3408   ushortp *arg1 = (ushortp *) 0 ;
3409   unsigned short arg2 ;
3410
3411   arg1 = (ushortp *)jarg1;
3412   arg2 = (unsigned short)jarg2;
3413   {
3414     try {
3415       ushortp_assign(arg1,arg2);
3416     } catch (std::out_of_range& e) {
3417       {
3418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3419       };
3420     } catch (std::exception& e) {
3421       {
3422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3423       };
3424     } catch (Dali::DaliException e) {
3425       {
3426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3427       };
3428     } catch (...) {
3429       {
3430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3431       };
3432     }
3433   }
3434
3435 }
3436
3437
3438 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3439   unsigned short jresult ;
3440   ushortp *arg1 = (ushortp *) 0 ;
3441   unsigned short result;
3442
3443   arg1 = (ushortp *)jarg1;
3444   {
3445     try {
3446       result = (unsigned short)ushortp_value(arg1);
3447     } catch (std::out_of_range& e) {
3448       {
3449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3450       };
3451     } catch (std::exception& e) {
3452       {
3453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3454       };
3455     } catch (Dali::DaliException e) {
3456       {
3457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3458       };
3459     } catch (...) {
3460       {
3461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3462       };
3463     }
3464   }
3465
3466   jresult = result;
3467   return jresult;
3468 }
3469
3470
3471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3472   void * jresult ;
3473   ushortp *arg1 = (ushortp *) 0 ;
3474   unsigned short *result = 0 ;
3475
3476   arg1 = (ushortp *)jarg1;
3477   {
3478     try {
3479       result = (unsigned short *)ushortp_cast(arg1);
3480     } catch (std::out_of_range& e) {
3481       {
3482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3483       };
3484     } catch (std::exception& e) {
3485       {
3486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3487       };
3488     } catch (Dali::DaliException e) {
3489       {
3490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3491       };
3492     } catch (...) {
3493       {
3494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3495       };
3496     }
3497   }
3498
3499   jresult = (void *)result;
3500   return jresult;
3501 }
3502
3503
3504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3505   void * jresult ;
3506   unsigned short *arg1 = (unsigned short *) 0 ;
3507   ushortp *result = 0 ;
3508
3509   arg1 = (unsigned short *)jarg1;
3510   {
3511     try {
3512       result = (ushortp *)ushortp_frompointer(arg1);
3513     } catch (std::out_of_range& e) {
3514       {
3515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3516       };
3517     } catch (std::exception& e) {
3518       {
3519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3520       };
3521     } catch (Dali::DaliException e) {
3522       {
3523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3524       };
3525     } catch (...) {
3526       {
3527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3528       };
3529     }
3530   }
3531
3532   jresult = (void *)result;
3533   return jresult;
3534 }
3535
3536
3537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3538   unsigned int jresult ;
3539   int arg1 ;
3540   unsigned int result;
3541
3542   arg1 = (int)jarg1;
3543   {
3544     try {
3545       result = (unsigned int)int_to_uint(arg1);
3546     } catch (std::out_of_range& e) {
3547       {
3548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3549       };
3550     } catch (std::exception& e) {
3551       {
3552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3553       };
3554     } catch (Dali::DaliException e) {
3555       {
3556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3557       };
3558     } catch (...) {
3559       {
3560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3561       };
3562     }
3563   }
3564
3565   jresult = result;
3566   return jresult;
3567 }
3568
3569
3570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3571   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3572
3573   arg1 = (Dali::RefObject *)jarg1;
3574   {
3575     try {
3576       (arg1)->Reference();
3577     } catch (std::out_of_range& e) {
3578       {
3579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3580       };
3581     } catch (std::exception& e) {
3582       {
3583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3584       };
3585     } catch (Dali::DaliException e) {
3586       {
3587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3588       };
3589     } catch (...) {
3590       {
3591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3592       };
3593     }
3594   }
3595
3596 }
3597
3598
3599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3600   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3601
3602   arg1 = (Dali::RefObject *)jarg1;
3603   {
3604     try {
3605       (arg1)->Unreference();
3606     } catch (std::out_of_range& e) {
3607       {
3608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3609       };
3610     } catch (std::exception& e) {
3611       {
3612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3613       };
3614     } catch (Dali::DaliException e) {
3615       {
3616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3617       };
3618     } catch (...) {
3619       {
3620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3621       };
3622     }
3623   }
3624
3625 }
3626
3627
3628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3629   int jresult ;
3630   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3631   int result;
3632
3633   arg1 = (Dali::RefObject *)jarg1;
3634   {
3635     try {
3636       result = (int)(arg1)->ReferenceCount();
3637     } catch (std::out_of_range& e) {
3638       {
3639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3640       };
3641     } catch (std::exception& e) {
3642       {
3643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3644       };
3645     } catch (Dali::DaliException e) {
3646       {
3647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3648       };
3649     } catch (...) {
3650       {
3651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3652       };
3653     }
3654   }
3655
3656   jresult = result;
3657   return jresult;
3658 }
3659
3660
3661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3662   void * jresult ;
3663   Dali::Any *result = 0 ;
3664
3665   {
3666     try {
3667       result = (Dali::Any *)new Dali::Any();
3668     } catch (std::out_of_range& e) {
3669       {
3670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3671       };
3672     } catch (std::exception& e) {
3673       {
3674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3675       };
3676     } catch (Dali::DaliException e) {
3677       {
3678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3679       };
3680     } catch (...) {
3681       {
3682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3683       };
3684     }
3685   }
3686
3687   jresult = (void *)result;
3688   return jresult;
3689 }
3690
3691
3692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3693   Dali::Any *arg1 = (Dali::Any *) 0 ;
3694
3695   arg1 = (Dali::Any *)jarg1;
3696   {
3697     try {
3698       delete arg1;
3699     } catch (std::out_of_range& e) {
3700       {
3701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3702       };
3703     } catch (std::exception& e) {
3704       {
3705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3706       };
3707     } catch (Dali::DaliException e) {
3708       {
3709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3710       };
3711     } catch (...) {
3712       {
3713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3714       };
3715     }
3716   }
3717
3718 }
3719
3720
3721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3722   char *arg1 = (char *) 0 ;
3723
3724   arg1 = (char *)jarg1;
3725   {
3726     try {
3727       Dali::Any::AssertAlways((char const *)arg1);
3728     } catch (std::out_of_range& e) {
3729       {
3730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3731       };
3732     } catch (std::exception& e) {
3733       {
3734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3735       };
3736     } catch (Dali::DaliException e) {
3737       {
3738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3739       };
3740     } catch (...) {
3741       {
3742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3743       };
3744     }
3745   }
3746
3747 }
3748
3749
3750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3751   void * jresult ;
3752   Dali::Any *arg1 = 0 ;
3753   Dali::Any *result = 0 ;
3754
3755   arg1 = (Dali::Any *)jarg1;
3756   if (!arg1) {
3757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3758     return 0;
3759   }
3760   {
3761     try {
3762       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3763     } catch (std::out_of_range& e) {
3764       {
3765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3766       };
3767     } catch (std::exception& e) {
3768       {
3769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3770       };
3771     } catch (Dali::DaliException e) {
3772       {
3773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3774       };
3775     } catch (...) {
3776       {
3777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3778       };
3779     }
3780   }
3781
3782   jresult = (void *)result;
3783   return jresult;
3784 }
3785
3786
3787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3788   void * jresult ;
3789   Dali::Any *arg1 = (Dali::Any *) 0 ;
3790   Dali::Any *arg2 = 0 ;
3791   Dali::Any *result = 0 ;
3792
3793   arg1 = (Dali::Any *)jarg1;
3794   arg2 = (Dali::Any *)jarg2;
3795   if (!arg2) {
3796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3797     return 0;
3798   }
3799   {
3800     try {
3801       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3802     } catch (std::out_of_range& e) {
3803       {
3804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3805       };
3806     } catch (std::exception& e) {
3807       {
3808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3809       };
3810     } catch (Dali::DaliException e) {
3811       {
3812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3813       };
3814     } catch (...) {
3815       {
3816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3817       };
3818     }
3819   }
3820
3821   jresult = (void *)result;
3822   return jresult;
3823 }
3824
3825
3826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3827   void * jresult ;
3828   Dali::Any *arg1 = (Dali::Any *) 0 ;
3829   std::type_info *result = 0 ;
3830
3831   arg1 = (Dali::Any *)jarg1;
3832   {
3833     try {
3834       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3835     } catch (std::out_of_range& e) {
3836       {
3837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3838       };
3839     } catch (std::exception& e) {
3840       {
3841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3842       };
3843     } catch (Dali::DaliException e) {
3844       {
3845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3846       };
3847     } catch (...) {
3848       {
3849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3850       };
3851     }
3852   }
3853
3854   jresult = (void *)result;
3855   return jresult;
3856 }
3857
3858
3859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3860   unsigned int jresult ;
3861   Dali::Any *arg1 = (Dali::Any *) 0 ;
3862   bool result;
3863
3864   arg1 = (Dali::Any *)jarg1;
3865   {
3866     try {
3867       result = (bool)((Dali::Any const *)arg1)->Empty();
3868     } catch (std::out_of_range& e) {
3869       {
3870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3871       };
3872     } catch (std::exception& e) {
3873       {
3874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3875       };
3876     } catch (Dali::DaliException e) {
3877       {
3878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3879       };
3880     } catch (...) {
3881       {
3882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3883       };
3884     }
3885   }
3886
3887   jresult = result;
3888   return jresult;
3889 }
3890
3891
3892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3893   void * jresult ;
3894   std::type_info *arg1 = 0 ;
3895   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3896   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3897   Dali::Any::AnyContainerBase *result = 0 ;
3898
3899   arg1 = (std::type_info *)jarg1;
3900   if (!arg1) {
3901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3902     return 0;
3903   }
3904   arg2 = (Dali::Any::CloneFunc)jarg2;
3905   arg3 = (Dali::Any::DeleteFunc)jarg3;
3906   {
3907     try {
3908       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3909     } catch (std::out_of_range& e) {
3910       {
3911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3912       };
3913     } catch (std::exception& e) {
3914       {
3915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3916       };
3917     } catch (Dali::DaliException e) {
3918       {
3919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3920       };
3921     } catch (...) {
3922       {
3923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3924       };
3925     }
3926   }
3927
3928   jresult = (void *)result;
3929   return jresult;
3930 }
3931
3932
3933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3934   void * jresult ;
3935   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3936   std::type_info *result = 0 ;
3937
3938   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3939   {
3940     try {
3941       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3942     } catch (std::out_of_range& e) {
3943       {
3944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3945       };
3946     } catch (std::exception& e) {
3947       {
3948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3949       };
3950     } catch (Dali::DaliException e) {
3951       {
3952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3953       };
3954     } catch (...) {
3955       {
3956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3957       };
3958     }
3959   }
3960
3961   jresult = (void *)result;
3962   return jresult;
3963 }
3964
3965
3966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3967   void * jresult ;
3968   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3969   ::std::type_info *result = 0 ;
3970
3971   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3972   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3973   jresult = (void *)result;
3974   return jresult;
3975 }
3976
3977
3978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3979   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3980   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3981
3982   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3983   arg2 = (Dali::Any::CloneFunc)jarg2;
3984   if (arg1) (arg1)->mCloneFunc = arg2;
3985 }
3986
3987
3988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3989   void * jresult ;
3990   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3991   Dali::Any::CloneFunc result;
3992
3993   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3994   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3995   jresult = (void *)result;
3996   return jresult;
3997 }
3998
3999
4000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4001   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4002   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4003
4004   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4005   arg2 = (Dali::Any::DeleteFunc)jarg2;
4006   if (arg1) (arg1)->mDeleteFunc = arg2;
4007 }
4008
4009
4010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4011   void * jresult ;
4012   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4013   Dali::Any::DeleteFunc result;
4014
4015   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4016   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4017   jresult = (void *)result;
4018   return jresult;
4019 }
4020
4021
4022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4023   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4024
4025   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4026   {
4027     try {
4028       delete arg1;
4029     } catch (std::out_of_range& e) {
4030       {
4031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4032       };
4033     } catch (std::exception& e) {
4034       {
4035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4036       };
4037     } catch (Dali::DaliException e) {
4038       {
4039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4040       };
4041     } catch (...) {
4042       {
4043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4044       };
4045     }
4046   }
4047
4048 }
4049
4050
4051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4052   Dali::Any *arg1 = (Dali::Any *) 0 ;
4053   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4054
4055   arg1 = (Dali::Any *)jarg1;
4056   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4057   if (arg1) (arg1)->mContainer = arg2;
4058 }
4059
4060
4061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4062   void * jresult ;
4063   Dali::Any *arg1 = (Dali::Any *) 0 ;
4064   Dali::Any::AnyContainerBase *result = 0 ;
4065
4066   arg1 = (Dali::Any *)jarg1;
4067   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4068   jresult = (void *)result;
4069   return jresult;
4070 }
4071
4072
4073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4074   char *arg1 = (char *) 0 ;
4075   char *arg2 = (char *) 0 ;
4076
4077   arg1 = (char *)jarg1;
4078   arg2 = (char *)jarg2;
4079   {
4080     try {
4081       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4082     } catch (std::out_of_range& e) {
4083       {
4084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4085       };
4086     } catch (std::exception& e) {
4087       {
4088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4089       };
4090     } catch (Dali::DaliException e) {
4091       {
4092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4093       };
4094     } catch (...) {
4095       {
4096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4097       };
4098     }
4099   }
4100
4101 }
4102
4103
4104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4105   void * jresult ;
4106   char *arg1 = (char *) 0 ;
4107   char *arg2 = (char *) 0 ;
4108   Dali::DaliException *result = 0 ;
4109
4110   arg1 = (char *)jarg1;
4111   arg2 = (char *)jarg2;
4112   {
4113     try {
4114       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4115     } catch (std::out_of_range& e) {
4116       {
4117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4118       };
4119     } catch (std::exception& e) {
4120       {
4121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4122       };
4123     } catch (Dali::DaliException e) {
4124       {
4125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4126       };
4127     } catch (...) {
4128       {
4129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4130       };
4131     }
4132   }
4133
4134   jresult = (void *)result;
4135   return jresult;
4136 }
4137
4138
4139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4140   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4141   std::string arg2 = std::string(jarg2);
4142
4143   arg1 = (Dali::DaliException *)jarg1;
4144   {
4145     if (!arg2.empty()) {
4146       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4147     } else {
4148       arg1->location = 0;
4149     }
4150   }
4151 }
4152
4153 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4154   char * jresult ;
4155   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4156   char *result = 0 ;
4157
4158   arg1 = (Dali::DaliException *)jarg1;
4159   result = (char *) ((arg1)->location);
4160   jresult = SWIG_csharp_string_callback((const char *)result);
4161   return jresult;
4162 }
4163
4164
4165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4166   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4167   std::string arg2 = std::string(jarg2);
4168
4169   arg1 = (Dali::DaliException *)jarg1;
4170   {
4171     if (!arg2.empty()) {
4172       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4173     } else {
4174       arg1->condition = 0;
4175     }
4176   }
4177 }
4178
4179
4180 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4181   char * jresult ;
4182   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4183   char *result = 0 ;
4184
4185   arg1 = (Dali::DaliException *)jarg1;
4186   result = (char *) ((arg1)->condition);
4187   jresult = SWIG_csharp_string_callback((const char *)result);
4188   return jresult;
4189 }
4190
4191
4192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4193   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4194
4195   arg1 = (Dali::DaliException *)jarg1;
4196   {
4197     try {
4198       delete arg1;
4199     } catch (std::out_of_range& e) {
4200       {
4201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4202       };
4203     } catch (std::exception& e) {
4204       {
4205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4206       };
4207     } catch (Dali::DaliException e) {
4208       {
4209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4210       };
4211     } catch (...) {
4212       {
4213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4214       };
4215     }
4216   }
4217
4218 }
4219
4220
4221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4222   void * jresult ;
4223   Dali::Vector2 *result = 0 ;
4224
4225   {
4226     try {
4227       result = (Dali::Vector2 *)new Dali::Vector2();
4228     } catch (std::out_of_range& e) {
4229       {
4230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4231       };
4232     } catch (std::exception& e) {
4233       {
4234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4235       };
4236     } catch (Dali::DaliException e) {
4237       {
4238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4239       };
4240     } catch (...) {
4241       {
4242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4243       };
4244     }
4245   }
4246
4247   jresult = (void *)result;
4248   return jresult;
4249 }
4250
4251
4252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4253   void * jresult ;
4254   float arg1 ;
4255   float arg2 ;
4256   Dali::Vector2 *result = 0 ;
4257
4258   arg1 = (float)jarg1;
4259   arg2 = (float)jarg2;
4260   {
4261     try {
4262       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4263     } catch (std::out_of_range& e) {
4264       {
4265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4266       };
4267     } catch (std::exception& e) {
4268       {
4269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4270       };
4271     } catch (Dali::DaliException e) {
4272       {
4273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4274       };
4275     } catch (...) {
4276       {
4277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4278       };
4279     }
4280   }
4281
4282   jresult = (void *)result;
4283   return jresult;
4284 }
4285
4286
4287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4288   void * jresult ;
4289   float *arg1 = (float *) 0 ;
4290   Dali::Vector2 *result = 0 ;
4291
4292   arg1 = jarg1;
4293   {
4294     try {
4295       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4296     } catch (std::out_of_range& e) {
4297       {
4298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4299       };
4300     } catch (std::exception& e) {
4301       {
4302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4303       };
4304     } catch (Dali::DaliException e) {
4305       {
4306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4307       };
4308     } catch (...) {
4309       {
4310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4311       };
4312     }
4313   }
4314
4315   jresult = (void *)result;
4316
4317
4318   return jresult;
4319 }
4320
4321
4322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4323   void * jresult ;
4324   Dali::Vector3 *arg1 = 0 ;
4325   Dali::Vector2 *result = 0 ;
4326
4327   arg1 = (Dali::Vector3 *)jarg1;
4328   if (!arg1) {
4329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4330     return 0;
4331   }
4332   {
4333     try {
4334       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4335     } catch (std::out_of_range& e) {
4336       {
4337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4338       };
4339     } catch (std::exception& e) {
4340       {
4341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4342       };
4343     } catch (Dali::DaliException e) {
4344       {
4345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4346       };
4347     } catch (...) {
4348       {
4349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4350       };
4351     }
4352   }
4353
4354   jresult = (void *)result;
4355   return jresult;
4356 }
4357
4358
4359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4360   void * jresult ;
4361   Dali::Vector4 *arg1 = 0 ;
4362   Dali::Vector2 *result = 0 ;
4363
4364   arg1 = (Dali::Vector4 *)jarg1;
4365   if (!arg1) {
4366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4367     return 0;
4368   }
4369   {
4370     try {
4371       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4372     } catch (std::out_of_range& e) {
4373       {
4374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4375       };
4376     } catch (std::exception& e) {
4377       {
4378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4379       };
4380     } catch (Dali::DaliException e) {
4381       {
4382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4383       };
4384     } catch (...) {
4385       {
4386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4387       };
4388     }
4389   }
4390
4391   jresult = (void *)result;
4392   return jresult;
4393 }
4394
4395
4396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4397   void * jresult ;
4398   Dali::Vector2 *result = 0 ;
4399
4400   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4401   jresult = (void *)result;
4402   return jresult;
4403 }
4404
4405
4406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4407   void * jresult ;
4408   Dali::Vector2 *result = 0 ;
4409
4410   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4411   jresult = (void *)result;
4412   return jresult;
4413 }
4414
4415
4416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4417   void * jresult ;
4418   Dali::Vector2 *result = 0 ;
4419
4420   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4421   jresult = (void *)result;
4422   return jresult;
4423 }
4424
4425
4426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4427   void * jresult ;
4428   Dali::Vector2 *result = 0 ;
4429
4430   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4431   jresult = (void *)result;
4432   return jresult;
4433 }
4434
4435
4436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4437   void * jresult ;
4438   Dali::Vector2 *result = 0 ;
4439
4440   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4441   jresult = (void *)result;
4442   return jresult;
4443 }
4444
4445
4446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4447   void * jresult ;
4448   Dali::Vector2 *result = 0 ;
4449
4450   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4451   jresult = (void *)result;
4452   return jresult;
4453 }
4454
4455
4456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4457   void * jresult ;
4458   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4459   float *arg2 = (float *) 0 ;
4460   Dali::Vector2 *result = 0 ;
4461
4462   arg1 = (Dali::Vector2 *)jarg1;
4463   arg2 = jarg2;
4464   {
4465     try {
4466       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4467     } catch (std::out_of_range& e) {
4468       {
4469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4470       };
4471     } catch (std::exception& e) {
4472       {
4473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4474       };
4475     } catch (Dali::DaliException e) {
4476       {
4477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4478       };
4479     } catch (...) {
4480       {
4481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4482       };
4483     }
4484   }
4485
4486   jresult = (void *)result;
4487
4488
4489   return jresult;
4490 }
4491
4492
4493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4494   void * jresult ;
4495   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4496   Dali::Vector3 *arg2 = 0 ;
4497   Dali::Vector2 *result = 0 ;
4498
4499   arg1 = (Dali::Vector2 *)jarg1;
4500   arg2 = (Dali::Vector3 *)jarg2;
4501   if (!arg2) {
4502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4503     return 0;
4504   }
4505   {
4506     try {
4507       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4508     } catch (std::out_of_range& e) {
4509       {
4510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4511       };
4512     } catch (std::exception& e) {
4513       {
4514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4515       };
4516     } catch (Dali::DaliException e) {
4517       {
4518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4519       };
4520     } catch (...) {
4521       {
4522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4523       };
4524     }
4525   }
4526
4527   jresult = (void *)result;
4528   return jresult;
4529 }
4530
4531
4532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4533   void * jresult ;
4534   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4535   Dali::Vector4 *arg2 = 0 ;
4536   Dali::Vector2 *result = 0 ;
4537
4538   arg1 = (Dali::Vector2 *)jarg1;
4539   arg2 = (Dali::Vector4 *)jarg2;
4540   if (!arg2) {
4541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4542     return 0;
4543   }
4544   {
4545     try {
4546       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4547     } catch (std::out_of_range& e) {
4548       {
4549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4550       };
4551     } catch (std::exception& e) {
4552       {
4553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4554       };
4555     } catch (Dali::DaliException e) {
4556       {
4557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4558       };
4559     } catch (...) {
4560       {
4561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4562       };
4563     }
4564   }
4565
4566   jresult = (void *)result;
4567   return jresult;
4568 }
4569
4570
4571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4572   void * jresult ;
4573   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4574   Dali::Vector2 *arg2 = 0 ;
4575   Dali::Vector2 result;
4576
4577   arg1 = (Dali::Vector2 *)jarg1;
4578   arg2 = (Dali::Vector2 *)jarg2;
4579   if (!arg2) {
4580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4581     return 0;
4582   }
4583   {
4584     try {
4585       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4586     } catch (std::out_of_range& e) {
4587       {
4588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4589       };
4590     } catch (std::exception& e) {
4591       {
4592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4593       };
4594     } catch (Dali::DaliException e) {
4595       {
4596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4597       };
4598     } catch (...) {
4599       {
4600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4601       };
4602     }
4603   }
4604
4605   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4606   return jresult;
4607 }
4608
4609
4610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4611   void * jresult ;
4612   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4613   Dali::Vector2 *arg2 = 0 ;
4614   Dali::Vector2 *result = 0 ;
4615
4616   arg1 = (Dali::Vector2 *)jarg1;
4617   arg2 = (Dali::Vector2 *)jarg2;
4618   if (!arg2) {
4619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4620     return 0;
4621   }
4622   {
4623     try {
4624       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4625     } catch (std::out_of_range& e) {
4626       {
4627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4628       };
4629     } catch (std::exception& e) {
4630       {
4631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4632       };
4633     } catch (Dali::DaliException e) {
4634       {
4635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4636       };
4637     } catch (...) {
4638       {
4639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4640       };
4641     }
4642   }
4643
4644   jresult = (void *)result;
4645   return jresult;
4646 }
4647
4648
4649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4650   void * jresult ;
4651   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4652   Dali::Vector2 *arg2 = 0 ;
4653   Dali::Vector2 result;
4654
4655   arg1 = (Dali::Vector2 *)jarg1;
4656   arg2 = (Dali::Vector2 *)jarg2;
4657   if (!arg2) {
4658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4659     return 0;
4660   }
4661   {
4662     try {
4663       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4664     } catch (std::out_of_range& e) {
4665       {
4666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4667       };
4668     } catch (std::exception& e) {
4669       {
4670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4671       };
4672     } catch (Dali::DaliException e) {
4673       {
4674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4675       };
4676     } catch (...) {
4677       {
4678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4679       };
4680     }
4681   }
4682
4683   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4684   return jresult;
4685 }
4686
4687
4688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4689   void * jresult ;
4690   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4691   Dali::Vector2 *arg2 = 0 ;
4692   Dali::Vector2 *result = 0 ;
4693
4694   arg1 = (Dali::Vector2 *)jarg1;
4695   arg2 = (Dali::Vector2 *)jarg2;
4696   if (!arg2) {
4697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4698     return 0;
4699   }
4700   {
4701     try {
4702       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4703     } catch (std::out_of_range& e) {
4704       {
4705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4706       };
4707     } catch (std::exception& e) {
4708       {
4709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4710       };
4711     } catch (Dali::DaliException e) {
4712       {
4713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4714       };
4715     } catch (...) {
4716       {
4717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4718       };
4719     }
4720   }
4721
4722   jresult = (void *)result;
4723   return jresult;
4724 }
4725
4726
4727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4728   void * jresult ;
4729   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4730   Dali::Vector2 *arg2 = 0 ;
4731   Dali::Vector2 result;
4732
4733   arg1 = (Dali::Vector2 *)jarg1;
4734   arg2 = (Dali::Vector2 *)jarg2;
4735   if (!arg2) {
4736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4737     return 0;
4738   }
4739   {
4740     try {
4741       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4742     } catch (std::out_of_range& e) {
4743       {
4744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4745       };
4746     } catch (std::exception& e) {
4747       {
4748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4749       };
4750     } catch (Dali::DaliException e) {
4751       {
4752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4753       };
4754     } catch (...) {
4755       {
4756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4757       };
4758     }
4759   }
4760
4761   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4762   return jresult;
4763 }
4764
4765
4766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4767   void * jresult ;
4768   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4769   float arg2 ;
4770   Dali::Vector2 result;
4771
4772   arg1 = (Dali::Vector2 *)jarg1;
4773   arg2 = (float)jarg2;
4774   {
4775     try {
4776       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4777     } catch (std::out_of_range& e) {
4778       {
4779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4780       };
4781     } catch (std::exception& e) {
4782       {
4783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4784       };
4785     } catch (Dali::DaliException e) {
4786       {
4787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4788       };
4789     } catch (...) {
4790       {
4791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4792       };
4793     }
4794   }
4795
4796   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4797   return jresult;
4798 }
4799
4800
4801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4802   void * jresult ;
4803   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4804   Dali::Vector2 *arg2 = 0 ;
4805   Dali::Vector2 *result = 0 ;
4806
4807   arg1 = (Dali::Vector2 *)jarg1;
4808   arg2 = (Dali::Vector2 *)jarg2;
4809   if (!arg2) {
4810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4811     return 0;
4812   }
4813   {
4814     try {
4815       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4816     } catch (std::out_of_range& e) {
4817       {
4818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4819       };
4820     } catch (std::exception& e) {
4821       {
4822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4823       };
4824     } catch (Dali::DaliException e) {
4825       {
4826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4827       };
4828     } catch (...) {
4829       {
4830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4831       };
4832     }
4833   }
4834
4835   jresult = (void *)result;
4836   return jresult;
4837 }
4838
4839
4840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4841   void * jresult ;
4842   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4843   float arg2 ;
4844   Dali::Vector2 *result = 0 ;
4845
4846   arg1 = (Dali::Vector2 *)jarg1;
4847   arg2 = (float)jarg2;
4848   {
4849     try {
4850       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4851     } catch (std::out_of_range& e) {
4852       {
4853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4854       };
4855     } catch (std::exception& e) {
4856       {
4857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4858       };
4859     } catch (Dali::DaliException e) {
4860       {
4861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4862       };
4863     } catch (...) {
4864       {
4865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4866       };
4867     }
4868   }
4869
4870   jresult = (void *)result;
4871   return jresult;
4872 }
4873
4874
4875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4876   void * jresult ;
4877   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4878   Dali::Vector2 *arg2 = 0 ;
4879   Dali::Vector2 result;
4880
4881   arg1 = (Dali::Vector2 *)jarg1;
4882   arg2 = (Dali::Vector2 *)jarg2;
4883   if (!arg2) {
4884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4885     return 0;
4886   }
4887   {
4888     try {
4889       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4890     } catch (std::out_of_range& e) {
4891       {
4892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4893       };
4894     } catch (std::exception& e) {
4895       {
4896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4897       };
4898     } catch (Dali::DaliException e) {
4899       {
4900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4901       };
4902     } catch (...) {
4903       {
4904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4905       };
4906     }
4907   }
4908
4909   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4910   return jresult;
4911 }
4912
4913
4914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4915   void * jresult ;
4916   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4917   float arg2 ;
4918   Dali::Vector2 result;
4919
4920   arg1 = (Dali::Vector2 *)jarg1;
4921   arg2 = (float)jarg2;
4922   {
4923     try {
4924       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4925     } catch (std::out_of_range& e) {
4926       {
4927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4928       };
4929     } catch (std::exception& e) {
4930       {
4931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4932       };
4933     } catch (Dali::DaliException e) {
4934       {
4935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4936       };
4937     } catch (...) {
4938       {
4939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4940       };
4941     }
4942   }
4943
4944   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4945   return jresult;
4946 }
4947
4948
4949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4950   void * jresult ;
4951   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4952   Dali::Vector2 *arg2 = 0 ;
4953   Dali::Vector2 *result = 0 ;
4954
4955   arg1 = (Dali::Vector2 *)jarg1;
4956   arg2 = (Dali::Vector2 *)jarg2;
4957   if (!arg2) {
4958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4959     return 0;
4960   }
4961   {
4962     try {
4963       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4964     } catch (std::out_of_range& e) {
4965       {
4966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4967       };
4968     } catch (std::exception& e) {
4969       {
4970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4971       };
4972     } catch (Dali::DaliException e) {
4973       {
4974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4975       };
4976     } catch (...) {
4977       {
4978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4979       };
4980     }
4981   }
4982
4983   jresult = (void *)result;
4984   return jresult;
4985 }
4986
4987
4988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4989   void * jresult ;
4990   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4991   float arg2 ;
4992   Dali::Vector2 *result = 0 ;
4993
4994   arg1 = (Dali::Vector2 *)jarg1;
4995   arg2 = (float)jarg2;
4996   {
4997     try {
4998       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4999     } catch (std::out_of_range& e) {
5000       {
5001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5002       };
5003     } catch (std::exception& e) {
5004       {
5005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5006       };
5007     } catch (Dali::DaliException e) {
5008       {
5009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5010       };
5011     } catch (...) {
5012       {
5013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5014       };
5015     }
5016   }
5017
5018   jresult = (void *)result;
5019   return jresult;
5020 }
5021
5022
5023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5024   void * jresult ;
5025   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5026   Dali::Vector2 result;
5027
5028   arg1 = (Dali::Vector2 *)jarg1;
5029   {
5030     try {
5031       result = ((Dali::Vector2 const *)arg1)->operator -();
5032     } catch (std::out_of_range& e) {
5033       {
5034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5035       };
5036     } catch (std::exception& e) {
5037       {
5038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5039       };
5040     } catch (Dali::DaliException e) {
5041       {
5042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5043       };
5044     } catch (...) {
5045       {
5046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5047       };
5048     }
5049   }
5050
5051   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5052   return jresult;
5053 }
5054
5055
5056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5057   unsigned int jresult ;
5058   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5059   Dali::Vector2 *arg2 = 0 ;
5060   bool result;
5061
5062   arg1 = (Dali::Vector2 *)jarg1;
5063   arg2 = (Dali::Vector2 *)jarg2;
5064   if (!arg2) {
5065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5066     return 0;
5067   }
5068   {
5069     try {
5070       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5071     } catch (std::out_of_range& e) {
5072       {
5073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5074       };
5075     } catch (std::exception& e) {
5076       {
5077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5078       };
5079     } catch (Dali::DaliException e) {
5080       {
5081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5082       };
5083     } catch (...) {
5084       {
5085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5086       };
5087     }
5088   }
5089
5090   jresult = result;
5091   return jresult;
5092 }
5093
5094
5095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5096   unsigned int jresult ;
5097   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5098   Dali::Vector2 *arg2 = 0 ;
5099   bool result;
5100
5101   arg1 = (Dali::Vector2 *)jarg1;
5102   arg2 = (Dali::Vector2 *)jarg2;
5103   if (!arg2) {
5104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5105     return 0;
5106   }
5107   {
5108     try {
5109       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5110     } catch (std::out_of_range& e) {
5111       {
5112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5113       };
5114     } catch (std::exception& e) {
5115       {
5116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5117       };
5118     } catch (Dali::DaliException e) {
5119       {
5120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5121       };
5122     } catch (...) {
5123       {
5124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5125       };
5126     }
5127   }
5128
5129   jresult = result;
5130   return jresult;
5131 }
5132
5133
5134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5135   float jresult ;
5136   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5137   unsigned int arg2 ;
5138   float *result = 0 ;
5139
5140   arg1 = (Dali::Vector2 *)jarg1;
5141   arg2 = (unsigned int)jarg2;
5142   {
5143     try {
5144       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5145     } catch (std::out_of_range& e) {
5146       {
5147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5148       };
5149     } catch (std::exception& e) {
5150       {
5151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5152       };
5153     } catch (Dali::DaliException e) {
5154       {
5155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5156       };
5157     } catch (...) {
5158       {
5159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5160       };
5161     }
5162   }
5163
5164   jresult = *result;
5165   return jresult;
5166 }
5167
5168
5169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5170   float jresult ;
5171   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5172   float result;
5173
5174   arg1 = (Dali::Vector2 *)jarg1;
5175   {
5176     try {
5177       result = (float)((Dali::Vector2 const *)arg1)->Length();
5178     } catch (std::out_of_range& e) {
5179       {
5180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5181       };
5182     } catch (std::exception& e) {
5183       {
5184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5185       };
5186     } catch (Dali::DaliException e) {
5187       {
5188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5189       };
5190     } catch (...) {
5191       {
5192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5193       };
5194     }
5195   }
5196
5197   jresult = result;
5198   return jresult;
5199 }
5200
5201
5202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5203   float jresult ;
5204   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5205   float result;
5206
5207   arg1 = (Dali::Vector2 *)jarg1;
5208   {
5209     try {
5210       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5211     } catch (std::out_of_range& e) {
5212       {
5213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5214       };
5215     } catch (std::exception& e) {
5216       {
5217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5218       };
5219     } catch (Dali::DaliException e) {
5220       {
5221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5222       };
5223     } catch (...) {
5224       {
5225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5226       };
5227     }
5228   }
5229
5230   jresult = result;
5231   return jresult;
5232 }
5233
5234
5235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5236   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5237
5238   arg1 = (Dali::Vector2 *)jarg1;
5239   {
5240     try {
5241       (arg1)->Normalize();
5242     } catch (std::out_of_range& e) {
5243       {
5244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5245       };
5246     } catch (std::exception& e) {
5247       {
5248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5249       };
5250     } catch (Dali::DaliException e) {
5251       {
5252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5253       };
5254     } catch (...) {
5255       {
5256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5257       };
5258     }
5259   }
5260
5261 }
5262
5263
5264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5265   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5266   Dali::Vector2 *arg2 = 0 ;
5267   Dali::Vector2 *arg3 = 0 ;
5268
5269   arg1 = (Dali::Vector2 *)jarg1;
5270   arg2 = (Dali::Vector2 *)jarg2;
5271   if (!arg2) {
5272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5273     return ;
5274   }
5275   arg3 = (Dali::Vector2 *)jarg3;
5276   if (!arg3) {
5277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5278     return ;
5279   }
5280   {
5281     try {
5282       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5283     } catch (std::out_of_range& e) {
5284       {
5285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5286       };
5287     } catch (std::exception& e) {
5288       {
5289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5290       };
5291     } catch (Dali::DaliException e) {
5292       {
5293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5294       };
5295     } catch (...) {
5296       {
5297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5298       };
5299     }
5300   }
5301
5302 }
5303
5304
5305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5306   void * jresult ;
5307   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5308   float *result = 0 ;
5309
5310   arg1 = (Dali::Vector2 *)jarg1;
5311   {
5312     try {
5313       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5314     } catch (std::out_of_range& e) {
5315       {
5316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5317       };
5318     } catch (std::exception& e) {
5319       {
5320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5321       };
5322     } catch (Dali::DaliException e) {
5323       {
5324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5325       };
5326     } catch (...) {
5327       {
5328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5329       };
5330     }
5331   }
5332
5333   jresult = (void *)result;
5334   return jresult;
5335 }
5336
5337
5338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5339   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5340   float arg2 ;
5341
5342   arg1 = (Dali::Vector2 *)jarg1;
5343   arg2 = (float)jarg2;
5344   if (arg1) (arg1)->x = arg2;
5345 }
5346
5347
5348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5349   float jresult ;
5350   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5351   float result;
5352
5353   arg1 = (Dali::Vector2 *)jarg1;
5354   result = (float) ((arg1)->x);
5355   jresult = result;
5356   return jresult;
5357 }
5358
5359
5360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5361   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5362   float arg2 ;
5363
5364   arg1 = (Dali::Vector2 *)jarg1;
5365   arg2 = (float)jarg2;
5366   if (arg1) (arg1)->width = arg2;
5367 }
5368
5369
5370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5371   float jresult ;
5372   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5373   float result;
5374
5375   arg1 = (Dali::Vector2 *)jarg1;
5376   result = (float) ((arg1)->width);
5377   jresult = result;
5378   return jresult;
5379 }
5380
5381
5382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5383   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5384   float arg2 ;
5385
5386   arg1 = (Dali::Vector2 *)jarg1;
5387   arg2 = (float)jarg2;
5388   if (arg1) (arg1)->y = arg2;
5389 }
5390
5391
5392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5393   float jresult ;
5394   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5395   float result;
5396
5397   arg1 = (Dali::Vector2 *)jarg1;
5398   result = (float) ((arg1)->y);
5399   jresult = result;
5400   return jresult;
5401 }
5402
5403
5404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5405   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5406   float arg2 ;
5407
5408   arg1 = (Dali::Vector2 *)jarg1;
5409   arg2 = (float)jarg2;
5410   if (arg1) (arg1)->height = arg2;
5411 }
5412
5413
5414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5415   float jresult ;
5416   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5417   float result;
5418
5419   arg1 = (Dali::Vector2 *)jarg1;
5420   result = (float) ((arg1)->height);
5421   jresult = result;
5422   return jresult;
5423 }
5424
5425
5426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5427   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5428
5429   arg1 = (Dali::Vector2 *)jarg1;
5430   {
5431     try {
5432       delete arg1;
5433     } catch (std::out_of_range& e) {
5434       {
5435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5436       };
5437     } catch (std::exception& e) {
5438       {
5439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5440       };
5441     } catch (Dali::DaliException e) {
5442       {
5443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5444       };
5445     } catch (...) {
5446       {
5447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5448       };
5449     }
5450   }
5451
5452 }
5453
5454
5455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5456   void * jresult ;
5457   Dali::Vector2 *arg1 = 0 ;
5458   Dali::Vector2 *arg2 = 0 ;
5459   Dali::Vector2 result;
5460
5461   arg1 = (Dali::Vector2 *)jarg1;
5462   if (!arg1) {
5463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5464     return 0;
5465   }
5466   arg2 = (Dali::Vector2 *)jarg2;
5467   if (!arg2) {
5468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5469     return 0;
5470   }
5471   {
5472     try {
5473       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5474     } catch (std::out_of_range& e) {
5475       {
5476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5477       };
5478     } catch (std::exception& e) {
5479       {
5480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5481       };
5482     } catch (Dali::DaliException e) {
5483       {
5484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5485       };
5486     } catch (...) {
5487       {
5488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5489       };
5490     }
5491   }
5492
5493   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5494   return jresult;
5495 }
5496
5497
5498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5499   void * jresult ;
5500   Dali::Vector2 *arg1 = 0 ;
5501   Dali::Vector2 *arg2 = 0 ;
5502   Dali::Vector2 result;
5503
5504   arg1 = (Dali::Vector2 *)jarg1;
5505   if (!arg1) {
5506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5507     return 0;
5508   }
5509   arg2 = (Dali::Vector2 *)jarg2;
5510   if (!arg2) {
5511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5512     return 0;
5513   }
5514   {
5515     try {
5516       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5517     } catch (std::out_of_range& e) {
5518       {
5519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5520       };
5521     } catch (std::exception& e) {
5522       {
5523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5524       };
5525     } catch (Dali::DaliException e) {
5526       {
5527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5528       };
5529     } catch (...) {
5530       {
5531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5532       };
5533     }
5534   }
5535
5536   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5537   return jresult;
5538 }
5539
5540
5541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5542   void * jresult ;
5543   Dali::Vector2 *arg1 = 0 ;
5544   float *arg2 = 0 ;
5545   float *arg3 = 0 ;
5546   float temp2 ;
5547   float temp3 ;
5548   Dali::Vector2 result;
5549
5550   arg1 = (Dali::Vector2 *)jarg1;
5551   if (!arg1) {
5552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5553     return 0;
5554   }
5555   temp2 = (float)jarg2;
5556   arg2 = &temp2;
5557   temp3 = (float)jarg3;
5558   arg3 = &temp3;
5559   {
5560     try {
5561       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5562     } catch (std::out_of_range& e) {
5563       {
5564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5565       };
5566     } catch (std::exception& e) {
5567       {
5568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5569       };
5570     } catch (Dali::DaliException e) {
5571       {
5572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5573       };
5574     } catch (...) {
5575       {
5576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5577       };
5578     }
5579   }
5580
5581   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5582   return jresult;
5583 }
5584
5585
5586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5587   void * jresult ;
5588   Dali::Vector3 *result = 0 ;
5589
5590   {
5591     try {
5592       result = (Dali::Vector3 *)new Dali::Vector3();
5593     } catch (std::out_of_range& e) {
5594       {
5595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5596       };
5597     } catch (std::exception& e) {
5598       {
5599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5600       };
5601     } catch (Dali::DaliException e) {
5602       {
5603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5604       };
5605     } catch (...) {
5606       {
5607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5608       };
5609     }
5610   }
5611
5612   jresult = (void *)result;
5613   return jresult;
5614 }
5615
5616
5617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5618   void * jresult ;
5619   float arg1 ;
5620   float arg2 ;
5621   float arg3 ;
5622   Dali::Vector3 *result = 0 ;
5623
5624   arg1 = (float)jarg1;
5625   arg2 = (float)jarg2;
5626   arg3 = (float)jarg3;
5627   {
5628     try {
5629       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5630     } catch (std::out_of_range& e) {
5631       {
5632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5633       };
5634     } catch (std::exception& e) {
5635       {
5636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5637       };
5638     } catch (Dali::DaliException e) {
5639       {
5640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5641       };
5642     } catch (...) {
5643       {
5644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5645       };
5646     }
5647   }
5648
5649   jresult = (void *)result;
5650   return jresult;
5651 }
5652
5653
5654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5655   void * jresult ;
5656   float *arg1 = (float *) 0 ;
5657   Dali::Vector3 *result = 0 ;
5658
5659   arg1 = jarg1;
5660   {
5661     try {
5662       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5663     } catch (std::out_of_range& e) {
5664       {
5665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5666       };
5667     } catch (std::exception& e) {
5668       {
5669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5670       };
5671     } catch (Dali::DaliException e) {
5672       {
5673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5674       };
5675     } catch (...) {
5676       {
5677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5678       };
5679     }
5680   }
5681
5682   jresult = (void *)result;
5683
5684
5685   return jresult;
5686 }
5687
5688
5689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5690   void * jresult ;
5691   Dali::Vector2 *arg1 = 0 ;
5692   Dali::Vector3 *result = 0 ;
5693
5694   arg1 = (Dali::Vector2 *)jarg1;
5695   if (!arg1) {
5696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5697     return 0;
5698   }
5699   {
5700     try {
5701       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5702     } catch (std::out_of_range& e) {
5703       {
5704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5705       };
5706     } catch (std::exception& e) {
5707       {
5708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5709       };
5710     } catch (Dali::DaliException e) {
5711       {
5712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5713       };
5714     } catch (...) {
5715       {
5716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5717       };
5718     }
5719   }
5720
5721   jresult = (void *)result;
5722   return jresult;
5723 }
5724
5725
5726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5727   void * jresult ;
5728   Dali::Vector4 *arg1 = 0 ;
5729   Dali::Vector3 *result = 0 ;
5730
5731   arg1 = (Dali::Vector4 *)jarg1;
5732   if (!arg1) {
5733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5734     return 0;
5735   }
5736   {
5737     try {
5738       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5739     } catch (std::out_of_range& e) {
5740       {
5741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5742       };
5743     } catch (std::exception& e) {
5744       {
5745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5746       };
5747     } catch (Dali::DaliException e) {
5748       {
5749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5750       };
5751     } catch (...) {
5752       {
5753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5754       };
5755     }
5756   }
5757
5758   jresult = (void *)result;
5759   return jresult;
5760 }
5761
5762
5763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5764   void * jresult ;
5765   Dali::Vector3 *result = 0 ;
5766
5767   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5768   jresult = (void *)result;
5769   return jresult;
5770 }
5771
5772
5773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5774   void * jresult ;
5775   Dali::Vector3 *result = 0 ;
5776
5777   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5778   jresult = (void *)result;
5779   return jresult;
5780 }
5781
5782
5783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5784   void * jresult ;
5785   Dali::Vector3 *result = 0 ;
5786
5787   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5788   jresult = (void *)result;
5789   return jresult;
5790 }
5791
5792
5793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5794   void * jresult ;
5795   Dali::Vector3 *result = 0 ;
5796
5797   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5798   jresult = (void *)result;
5799   return jresult;
5800 }
5801
5802
5803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5804   void * jresult ;
5805   Dali::Vector3 *result = 0 ;
5806
5807   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5808   jresult = (void *)result;
5809   return jresult;
5810 }
5811
5812
5813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5814   void * jresult ;
5815   Dali::Vector3 *result = 0 ;
5816
5817   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5818   jresult = (void *)result;
5819   return jresult;
5820 }
5821
5822
5823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5824   void * jresult ;
5825   Dali::Vector3 *result = 0 ;
5826
5827   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5828   jresult = (void *)result;
5829   return jresult;
5830 }
5831
5832
5833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5834   void * jresult ;
5835   Dali::Vector3 *result = 0 ;
5836
5837   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5838   jresult = (void *)result;
5839   return jresult;
5840 }
5841
5842
5843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5844   void * jresult ;
5845   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5846   float *arg2 = (float *) 0 ;
5847   Dali::Vector3 *result = 0 ;
5848
5849   arg1 = (Dali::Vector3 *)jarg1;
5850   arg2 = jarg2;
5851   {
5852     try {
5853       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5854     } catch (std::out_of_range& e) {
5855       {
5856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5857       };
5858     } catch (std::exception& e) {
5859       {
5860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5861       };
5862     } catch (Dali::DaliException e) {
5863       {
5864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5865       };
5866     } catch (...) {
5867       {
5868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5869       };
5870     }
5871   }
5872
5873   jresult = (void *)result;
5874
5875
5876   return jresult;
5877 }
5878
5879
5880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5881   void * jresult ;
5882   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5883   Dali::Vector2 *arg2 = 0 ;
5884   Dali::Vector3 *result = 0 ;
5885
5886   arg1 = (Dali::Vector3 *)jarg1;
5887   arg2 = (Dali::Vector2 *)jarg2;
5888   if (!arg2) {
5889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5890     return 0;
5891   }
5892   {
5893     try {
5894       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5895     } catch (std::out_of_range& e) {
5896       {
5897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5898       };
5899     } catch (std::exception& e) {
5900       {
5901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5902       };
5903     } catch (Dali::DaliException e) {
5904       {
5905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5906       };
5907     } catch (...) {
5908       {
5909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5910       };
5911     }
5912   }
5913
5914   jresult = (void *)result;
5915   return jresult;
5916 }
5917
5918
5919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5920   void * jresult ;
5921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5922   Dali::Vector4 *arg2 = 0 ;
5923   Dali::Vector3 *result = 0 ;
5924
5925   arg1 = (Dali::Vector3 *)jarg1;
5926   arg2 = (Dali::Vector4 *)jarg2;
5927   if (!arg2) {
5928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5929     return 0;
5930   }
5931   {
5932     try {
5933       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5934     } catch (std::out_of_range& e) {
5935       {
5936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5937       };
5938     } catch (std::exception& e) {
5939       {
5940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5941       };
5942     } catch (Dali::DaliException e) {
5943       {
5944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5945       };
5946     } catch (...) {
5947       {
5948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5949       };
5950     }
5951   }
5952
5953   jresult = (void *)result;
5954   return jresult;
5955 }
5956
5957
5958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5959   void * jresult ;
5960   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5961   Dali::Vector3 *arg2 = 0 ;
5962   Dali::Vector3 result;
5963
5964   arg1 = (Dali::Vector3 *)jarg1;
5965   arg2 = (Dali::Vector3 *)jarg2;
5966   if (!arg2) {
5967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5968     return 0;
5969   }
5970   {
5971     try {
5972       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5973     } catch (std::out_of_range& e) {
5974       {
5975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5976       };
5977     } catch (std::exception& e) {
5978       {
5979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5980       };
5981     } catch (Dali::DaliException e) {
5982       {
5983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5984       };
5985     } catch (...) {
5986       {
5987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5988       };
5989     }
5990   }
5991
5992   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5993   return jresult;
5994 }
5995
5996
5997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5998   void * jresult ;
5999   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6000   Dali::Vector3 *arg2 = 0 ;
6001   Dali::Vector3 *result = 0 ;
6002
6003   arg1 = (Dali::Vector3 *)jarg1;
6004   arg2 = (Dali::Vector3 *)jarg2;
6005   if (!arg2) {
6006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6007     return 0;
6008   }
6009   {
6010     try {
6011       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6012     } catch (std::out_of_range& e) {
6013       {
6014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6015       };
6016     } catch (std::exception& e) {
6017       {
6018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6019       };
6020     } catch (Dali::DaliException e) {
6021       {
6022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6023       };
6024     } catch (...) {
6025       {
6026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6027       };
6028     }
6029   }
6030
6031   jresult = (void *)result;
6032   return jresult;
6033 }
6034
6035
6036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6037   void * jresult ;
6038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6039   Dali::Vector3 *arg2 = 0 ;
6040   Dali::Vector3 result;
6041
6042   arg1 = (Dali::Vector3 *)jarg1;
6043   arg2 = (Dali::Vector3 *)jarg2;
6044   if (!arg2) {
6045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6046     return 0;
6047   }
6048   {
6049     try {
6050       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6051     } catch (std::out_of_range& e) {
6052       {
6053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6054       };
6055     } catch (std::exception& e) {
6056       {
6057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6058       };
6059     } catch (Dali::DaliException e) {
6060       {
6061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6062       };
6063     } catch (...) {
6064       {
6065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6066       };
6067     }
6068   }
6069
6070   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6071   return jresult;
6072 }
6073
6074
6075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6076   void * jresult ;
6077   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6078   Dali::Vector3 *arg2 = 0 ;
6079   Dali::Vector3 *result = 0 ;
6080
6081   arg1 = (Dali::Vector3 *)jarg1;
6082   arg2 = (Dali::Vector3 *)jarg2;
6083   if (!arg2) {
6084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6085     return 0;
6086   }
6087   {
6088     try {
6089       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6090     } catch (std::out_of_range& e) {
6091       {
6092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6093       };
6094     } catch (std::exception& e) {
6095       {
6096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6097       };
6098     } catch (Dali::DaliException e) {
6099       {
6100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6101       };
6102     } catch (...) {
6103       {
6104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6105       };
6106     }
6107   }
6108
6109   jresult = (void *)result;
6110   return jresult;
6111 }
6112
6113
6114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6115   void * jresult ;
6116   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6117   Dali::Vector3 *arg2 = 0 ;
6118   Dali::Vector3 result;
6119
6120   arg1 = (Dali::Vector3 *)jarg1;
6121   arg2 = (Dali::Vector3 *)jarg2;
6122   if (!arg2) {
6123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6124     return 0;
6125   }
6126   {
6127     try {
6128       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6129     } catch (std::out_of_range& e) {
6130       {
6131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6132       };
6133     } catch (std::exception& e) {
6134       {
6135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6136       };
6137     } catch (Dali::DaliException e) {
6138       {
6139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6140       };
6141     } catch (...) {
6142       {
6143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6144       };
6145     }
6146   }
6147
6148   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6149   return jresult;
6150 }
6151
6152
6153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6154   void * jresult ;
6155   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6156   float arg2 ;
6157   Dali::Vector3 result;
6158
6159   arg1 = (Dali::Vector3 *)jarg1;
6160   arg2 = (float)jarg2;
6161   {
6162     try {
6163       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6164     } catch (std::out_of_range& e) {
6165       {
6166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6167       };
6168     } catch (std::exception& e) {
6169       {
6170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6171       };
6172     } catch (Dali::DaliException e) {
6173       {
6174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6175       };
6176     } catch (...) {
6177       {
6178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6179       };
6180     }
6181   }
6182
6183   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6184   return jresult;
6185 }
6186
6187
6188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6189   void * jresult ;
6190   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6191   Dali::Vector3 *arg2 = 0 ;
6192   Dali::Vector3 *result = 0 ;
6193
6194   arg1 = (Dali::Vector3 *)jarg1;
6195   arg2 = (Dali::Vector3 *)jarg2;
6196   if (!arg2) {
6197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6198     return 0;
6199   }
6200   {
6201     try {
6202       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6203     } catch (std::out_of_range& e) {
6204       {
6205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6206       };
6207     } catch (std::exception& e) {
6208       {
6209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6210       };
6211     } catch (Dali::DaliException e) {
6212       {
6213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6214       };
6215     } catch (...) {
6216       {
6217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6218       };
6219     }
6220   }
6221
6222   jresult = (void *)result;
6223   return jresult;
6224 }
6225
6226
6227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6228   void * jresult ;
6229   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6230   float arg2 ;
6231   Dali::Vector3 *result = 0 ;
6232
6233   arg1 = (Dali::Vector3 *)jarg1;
6234   arg2 = (float)jarg2;
6235   {
6236     try {
6237       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6238     } catch (std::out_of_range& e) {
6239       {
6240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6241       };
6242     } catch (std::exception& e) {
6243       {
6244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6245       };
6246     } catch (Dali::DaliException e) {
6247       {
6248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6249       };
6250     } catch (...) {
6251       {
6252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6253       };
6254     }
6255   }
6256
6257   jresult = (void *)result;
6258   return jresult;
6259 }
6260
6261
6262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6263   void * jresult ;
6264   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6265   Dali::Quaternion *arg2 = 0 ;
6266   Dali::Vector3 *result = 0 ;
6267
6268   arg1 = (Dali::Vector3 *)jarg1;
6269   arg2 = (Dali::Quaternion *)jarg2;
6270   if (!arg2) {
6271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6272     return 0;
6273   }
6274   {
6275     try {
6276       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6277     } catch (std::out_of_range& e) {
6278       {
6279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6280       };
6281     } catch (std::exception& e) {
6282       {
6283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6284       };
6285     } catch (Dali::DaliException e) {
6286       {
6287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6288       };
6289     } catch (...) {
6290       {
6291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6292       };
6293     }
6294   }
6295
6296   jresult = (void *)result;
6297   return jresult;
6298 }
6299
6300
6301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6302   void * jresult ;
6303   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6304   Dali::Vector3 *arg2 = 0 ;
6305   Dali::Vector3 result;
6306
6307   arg1 = (Dali::Vector3 *)jarg1;
6308   arg2 = (Dali::Vector3 *)jarg2;
6309   if (!arg2) {
6310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6311     return 0;
6312   }
6313   {
6314     try {
6315       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6316     } catch (std::out_of_range& e) {
6317       {
6318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6319       };
6320     } catch (std::exception& e) {
6321       {
6322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6323       };
6324     } catch (Dali::DaliException e) {
6325       {
6326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6327       };
6328     } catch (...) {
6329       {
6330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6331       };
6332     }
6333   }
6334
6335   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6336   return jresult;
6337 }
6338
6339
6340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6341   void * jresult ;
6342   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6343   float arg2 ;
6344   Dali::Vector3 result;
6345
6346   arg1 = (Dali::Vector3 *)jarg1;
6347   arg2 = (float)jarg2;
6348   {
6349     try {
6350       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6351     } catch (std::out_of_range& e) {
6352       {
6353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6354       };
6355     } catch (std::exception& e) {
6356       {
6357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6358       };
6359     } catch (Dali::DaliException e) {
6360       {
6361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6362       };
6363     } catch (...) {
6364       {
6365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6366       };
6367     }
6368   }
6369
6370   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6371   return jresult;
6372 }
6373
6374
6375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6376   void * jresult ;
6377   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6378   Dali::Vector3 *arg2 = 0 ;
6379   Dali::Vector3 *result = 0 ;
6380
6381   arg1 = (Dali::Vector3 *)jarg1;
6382   arg2 = (Dali::Vector3 *)jarg2;
6383   if (!arg2) {
6384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6385     return 0;
6386   }
6387   {
6388     try {
6389       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6390     } catch (std::out_of_range& e) {
6391       {
6392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6393       };
6394     } catch (std::exception& e) {
6395       {
6396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6397       };
6398     } catch (Dali::DaliException e) {
6399       {
6400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6401       };
6402     } catch (...) {
6403       {
6404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6405       };
6406     }
6407   }
6408
6409   jresult = (void *)result;
6410   return jresult;
6411 }
6412
6413
6414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6415   void * jresult ;
6416   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6417   float arg2 ;
6418   Dali::Vector3 *result = 0 ;
6419
6420   arg1 = (Dali::Vector3 *)jarg1;
6421   arg2 = (float)jarg2;
6422   {
6423     try {
6424       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6425     } catch (std::out_of_range& e) {
6426       {
6427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6428       };
6429     } catch (std::exception& e) {
6430       {
6431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6432       };
6433     } catch (Dali::DaliException e) {
6434       {
6435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6436       };
6437     } catch (...) {
6438       {
6439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6440       };
6441     }
6442   }
6443
6444   jresult = (void *)result;
6445   return jresult;
6446 }
6447
6448
6449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6450   void * jresult ;
6451   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6452   Dali::Vector3 result;
6453
6454   arg1 = (Dali::Vector3 *)jarg1;
6455   {
6456     try {
6457       result = ((Dali::Vector3 const *)arg1)->operator -();
6458     } catch (std::out_of_range& e) {
6459       {
6460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6461       };
6462     } catch (std::exception& e) {
6463       {
6464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6465       };
6466     } catch (Dali::DaliException e) {
6467       {
6468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6469       };
6470     } catch (...) {
6471       {
6472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6473       };
6474     }
6475   }
6476
6477   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6478   return jresult;
6479 }
6480
6481
6482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6483   unsigned int jresult ;
6484   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6485   Dali::Vector3 *arg2 = 0 ;
6486   bool result;
6487
6488   arg1 = (Dali::Vector3 *)jarg1;
6489   arg2 = (Dali::Vector3 *)jarg2;
6490   if (!arg2) {
6491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6492     return 0;
6493   }
6494   {
6495     try {
6496       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6497     } catch (std::out_of_range& e) {
6498       {
6499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6500       };
6501     } catch (std::exception& e) {
6502       {
6503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6504       };
6505     } catch (Dali::DaliException e) {
6506       {
6507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6508       };
6509     } catch (...) {
6510       {
6511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6512       };
6513     }
6514   }
6515
6516   jresult = result;
6517   return jresult;
6518 }
6519
6520
6521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6522   unsigned int jresult ;
6523   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6524   Dali::Vector3 *arg2 = 0 ;
6525   bool result;
6526
6527   arg1 = (Dali::Vector3 *)jarg1;
6528   arg2 = (Dali::Vector3 *)jarg2;
6529   if (!arg2) {
6530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6531     return 0;
6532   }
6533   {
6534     try {
6535       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6536     } catch (std::out_of_range& e) {
6537       {
6538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6539       };
6540     } catch (std::exception& e) {
6541       {
6542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6543       };
6544     } catch (Dali::DaliException e) {
6545       {
6546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6547       };
6548     } catch (...) {
6549       {
6550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6551       };
6552     }
6553   }
6554
6555   jresult = result;
6556   return jresult;
6557 }
6558
6559
6560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6561   float jresult ;
6562   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6563   unsigned int arg2 ;
6564   float *result = 0 ;
6565
6566   arg1 = (Dali::Vector3 *)jarg1;
6567   arg2 = (unsigned int)jarg2;
6568   {
6569     try {
6570       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6571     } catch (std::out_of_range& e) {
6572       {
6573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6574       };
6575     } catch (std::exception& e) {
6576       {
6577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6578       };
6579     } catch (Dali::DaliException e) {
6580       {
6581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6582       };
6583     } catch (...) {
6584       {
6585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6586       };
6587     }
6588   }
6589
6590   jresult = *result;
6591   return jresult;
6592 }
6593
6594
6595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6596   float jresult ;
6597   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6598   Dali::Vector3 *arg2 = 0 ;
6599   float result;
6600
6601   arg1 = (Dali::Vector3 *)jarg1;
6602   arg2 = (Dali::Vector3 *)jarg2;
6603   if (!arg2) {
6604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6605     return 0;
6606   }
6607   {
6608     try {
6609       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6610     } catch (std::out_of_range& e) {
6611       {
6612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6613       };
6614     } catch (std::exception& e) {
6615       {
6616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6617       };
6618     } catch (Dali::DaliException e) {
6619       {
6620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6621       };
6622     } catch (...) {
6623       {
6624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6625       };
6626     }
6627   }
6628
6629   jresult = result;
6630   return jresult;
6631 }
6632
6633
6634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6635   void * jresult ;
6636   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6637   Dali::Vector3 *arg2 = 0 ;
6638   Dali::Vector3 result;
6639
6640   arg1 = (Dali::Vector3 *)jarg1;
6641   arg2 = (Dali::Vector3 *)jarg2;
6642   if (!arg2) {
6643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6644     return 0;
6645   }
6646   {
6647     try {
6648       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6649     } catch (std::out_of_range& e) {
6650       {
6651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6652       };
6653     } catch (std::exception& e) {
6654       {
6655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6656       };
6657     } catch (Dali::DaliException e) {
6658       {
6659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6660       };
6661     } catch (...) {
6662       {
6663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6664       };
6665     }
6666   }
6667
6668   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6669   return jresult;
6670 }
6671
6672
6673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6674   float jresult ;
6675   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6676   float result;
6677
6678   arg1 = (Dali::Vector3 *)jarg1;
6679   {
6680     try {
6681       result = (float)((Dali::Vector3 const *)arg1)->Length();
6682     } catch (std::out_of_range& e) {
6683       {
6684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6685       };
6686     } catch (std::exception& e) {
6687       {
6688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6689       };
6690     } catch (Dali::DaliException e) {
6691       {
6692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6693       };
6694     } catch (...) {
6695       {
6696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6697       };
6698     }
6699   }
6700
6701   jresult = result;
6702   return jresult;
6703 }
6704
6705
6706 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6707   float jresult ;
6708   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6709   float result;
6710
6711   arg1 = (Dali::Vector3 *)jarg1;
6712   {
6713     try {
6714       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6715     } catch (std::out_of_range& e) {
6716       {
6717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6718       };
6719     } catch (std::exception& e) {
6720       {
6721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6722       };
6723     } catch (Dali::DaliException e) {
6724       {
6725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6726       };
6727     } catch (...) {
6728       {
6729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6730       };
6731     }
6732   }
6733
6734   jresult = result;
6735   return jresult;
6736 }
6737
6738
6739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6740   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6741
6742   arg1 = (Dali::Vector3 *)jarg1;
6743   {
6744     try {
6745       (arg1)->Normalize();
6746     } catch (std::out_of_range& e) {
6747       {
6748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6749       };
6750     } catch (std::exception& e) {
6751       {
6752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6753       };
6754     } catch (Dali::DaliException e) {
6755       {
6756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6757       };
6758     } catch (...) {
6759       {
6760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6761       };
6762     }
6763   }
6764
6765 }
6766
6767
6768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6769   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6770   Dali::Vector3 *arg2 = 0 ;
6771   Dali::Vector3 *arg3 = 0 ;
6772
6773   arg1 = (Dali::Vector3 *)jarg1;
6774   arg2 = (Dali::Vector3 *)jarg2;
6775   if (!arg2) {
6776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6777     return ;
6778   }
6779   arg3 = (Dali::Vector3 *)jarg3;
6780   if (!arg3) {
6781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6782     return ;
6783   }
6784   {
6785     try {
6786       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6787     } catch (std::out_of_range& e) {
6788       {
6789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6790       };
6791     } catch (std::exception& e) {
6792       {
6793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6794       };
6795     } catch (Dali::DaliException e) {
6796       {
6797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6798       };
6799     } catch (...) {
6800       {
6801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6802       };
6803     }
6804   }
6805
6806 }
6807
6808
6809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6810   void * jresult ;
6811   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6812   float *result = 0 ;
6813
6814   arg1 = (Dali::Vector3 *)jarg1;
6815   {
6816     try {
6817       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6818     } catch (std::out_of_range& e) {
6819       {
6820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6821       };
6822     } catch (std::exception& e) {
6823       {
6824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6825       };
6826     } catch (Dali::DaliException e) {
6827       {
6828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6829       };
6830     } catch (...) {
6831       {
6832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6833       };
6834     }
6835   }
6836
6837   jresult = (void *)result;
6838   return jresult;
6839 }
6840
6841
6842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6843   void * jresult ;
6844   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6845   Dali::Vector2 *result = 0 ;
6846
6847   arg1 = (Dali::Vector3 *)jarg1;
6848   {
6849     try {
6850       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6851     } catch (std::out_of_range& e) {
6852       {
6853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6854       };
6855     } catch (std::exception& e) {
6856       {
6857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6858       };
6859     } catch (Dali::DaliException e) {
6860       {
6861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6862       };
6863     } catch (...) {
6864       {
6865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6866       };
6867     }
6868   }
6869
6870   jresult = (void *)result;
6871   return jresult;
6872 }
6873
6874
6875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6876   void * jresult ;
6877   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6878   Dali::Vector2 *result = 0 ;
6879
6880   arg1 = (Dali::Vector3 *)jarg1;
6881   {
6882     try {
6883       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6884     } catch (std::out_of_range& e) {
6885       {
6886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6887       };
6888     } catch (std::exception& e) {
6889       {
6890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6891       };
6892     } catch (Dali::DaliException e) {
6893       {
6894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6895       };
6896     } catch (...) {
6897       {
6898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6899       };
6900     }
6901   }
6902
6903   jresult = (void *)result;
6904   return jresult;
6905 }
6906
6907
6908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6909   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6910   float arg2 ;
6911
6912   arg1 = (Dali::Vector3 *)jarg1;
6913   arg2 = (float)jarg2;
6914   if (arg1) (arg1)->x = arg2;
6915 }
6916
6917
6918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6919   float jresult ;
6920   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6921   float result;
6922
6923   arg1 = (Dali::Vector3 *)jarg1;
6924   result = (float) ((arg1)->x);
6925   jresult = result;
6926   return jresult;
6927 }
6928
6929
6930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6931   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6932   float arg2 ;
6933
6934   arg1 = (Dali::Vector3 *)jarg1;
6935   arg2 = (float)jarg2;
6936   if (arg1) (arg1)->width = arg2;
6937 }
6938
6939
6940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6941   float jresult ;
6942   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6943   float result;
6944
6945   arg1 = (Dali::Vector3 *)jarg1;
6946   result = (float) ((arg1)->width);
6947   jresult = result;
6948   return jresult;
6949 }
6950
6951
6952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6953   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6954   float arg2 ;
6955
6956   arg1 = (Dali::Vector3 *)jarg1;
6957   arg2 = (float)jarg2;
6958   if (arg1) (arg1)->r = arg2;
6959 }
6960
6961
6962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6963   float jresult ;
6964   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6965   float result;
6966
6967   arg1 = (Dali::Vector3 *)jarg1;
6968   result = (float) ((arg1)->r);
6969   jresult = result;
6970   return jresult;
6971 }
6972
6973
6974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6975   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6976   float arg2 ;
6977
6978   arg1 = (Dali::Vector3 *)jarg1;
6979   arg2 = (float)jarg2;
6980   if (arg1) (arg1)->y = arg2;
6981 }
6982
6983
6984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6985   float jresult ;
6986   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6987   float result;
6988
6989   arg1 = (Dali::Vector3 *)jarg1;
6990   result = (float) ((arg1)->y);
6991   jresult = result;
6992   return jresult;
6993 }
6994
6995
6996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6997   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6998   float arg2 ;
6999
7000   arg1 = (Dali::Vector3 *)jarg1;
7001   arg2 = (float)jarg2;
7002   if (arg1) (arg1)->height = arg2;
7003 }
7004
7005
7006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7007   float jresult ;
7008   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7009   float result;
7010
7011   arg1 = (Dali::Vector3 *)jarg1;
7012   result = (float) ((arg1)->height);
7013   jresult = result;
7014   return jresult;
7015 }
7016
7017
7018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7019   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7020   float arg2 ;
7021
7022   arg1 = (Dali::Vector3 *)jarg1;
7023   arg2 = (float)jarg2;
7024   if (arg1) (arg1)->g = arg2;
7025 }
7026
7027
7028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7029   float jresult ;
7030   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7031   float result;
7032
7033   arg1 = (Dali::Vector3 *)jarg1;
7034   result = (float) ((arg1)->g);
7035   jresult = result;
7036   return jresult;
7037 }
7038
7039
7040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7042   float arg2 ;
7043
7044   arg1 = (Dali::Vector3 *)jarg1;
7045   arg2 = (float)jarg2;
7046   if (arg1) (arg1)->z = arg2;
7047 }
7048
7049
7050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7051   float jresult ;
7052   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7053   float result;
7054
7055   arg1 = (Dali::Vector3 *)jarg1;
7056   result = (float) ((arg1)->z);
7057   jresult = result;
7058   return jresult;
7059 }
7060
7061
7062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7063   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7064   float arg2 ;
7065
7066   arg1 = (Dali::Vector3 *)jarg1;
7067   arg2 = (float)jarg2;
7068   if (arg1) (arg1)->depth = arg2;
7069 }
7070
7071
7072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7073   float jresult ;
7074   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7075   float result;
7076
7077   arg1 = (Dali::Vector3 *)jarg1;
7078   result = (float) ((arg1)->depth);
7079   jresult = result;
7080   return jresult;
7081 }
7082
7083
7084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7085   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7086   float arg2 ;
7087
7088   arg1 = (Dali::Vector3 *)jarg1;
7089   arg2 = (float)jarg2;
7090   if (arg1) (arg1)->b = arg2;
7091 }
7092
7093
7094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7095   float jresult ;
7096   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7097   float result;
7098
7099   arg1 = (Dali::Vector3 *)jarg1;
7100   result = (float) ((arg1)->b);
7101   jresult = result;
7102   return jresult;
7103 }
7104
7105
7106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7107   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7108
7109   arg1 = (Dali::Vector3 *)jarg1;
7110   {
7111     try {
7112       delete arg1;
7113     } catch (std::out_of_range& e) {
7114       {
7115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7116       };
7117     } catch (std::exception& e) {
7118       {
7119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7120       };
7121     } catch (Dali::DaliException e) {
7122       {
7123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7124       };
7125     } catch (...) {
7126       {
7127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7128       };
7129     }
7130   }
7131
7132 }
7133
7134
7135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7136   void * jresult ;
7137   Dali::Vector3 *arg1 = 0 ;
7138   Dali::Vector3 *arg2 = 0 ;
7139   Dali::Vector3 result;
7140
7141   arg1 = (Dali::Vector3 *)jarg1;
7142   if (!arg1) {
7143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7144     return 0;
7145   }
7146   arg2 = (Dali::Vector3 *)jarg2;
7147   if (!arg2) {
7148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7149     return 0;
7150   }
7151   {
7152     try {
7153       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7154     } catch (std::out_of_range& e) {
7155       {
7156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7157       };
7158     } catch (std::exception& e) {
7159       {
7160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7161       };
7162     } catch (Dali::DaliException e) {
7163       {
7164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7165       };
7166     } catch (...) {
7167       {
7168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7169       };
7170     }
7171   }
7172
7173   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7174   return jresult;
7175 }
7176
7177
7178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7179   void * jresult ;
7180   Dali::Vector3 *arg1 = 0 ;
7181   Dali::Vector3 *arg2 = 0 ;
7182   Dali::Vector3 result;
7183
7184   arg1 = (Dali::Vector3 *)jarg1;
7185   if (!arg1) {
7186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7187     return 0;
7188   }
7189   arg2 = (Dali::Vector3 *)jarg2;
7190   if (!arg2) {
7191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7192     return 0;
7193   }
7194   {
7195     try {
7196       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7197     } catch (std::out_of_range& e) {
7198       {
7199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7200       };
7201     } catch (std::exception& e) {
7202       {
7203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7204       };
7205     } catch (Dali::DaliException e) {
7206       {
7207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7208       };
7209     } catch (...) {
7210       {
7211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7212       };
7213     }
7214   }
7215
7216   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7217   return jresult;
7218 }
7219
7220
7221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7222   void * jresult ;
7223   Dali::Vector3 *arg1 = 0 ;
7224   float *arg2 = 0 ;
7225   float *arg3 = 0 ;
7226   float temp2 ;
7227   float temp3 ;
7228   Dali::Vector3 result;
7229
7230   arg1 = (Dali::Vector3 *)jarg1;
7231   if (!arg1) {
7232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7233     return 0;
7234   }
7235   temp2 = (float)jarg2;
7236   arg2 = &temp2;
7237   temp3 = (float)jarg3;
7238   arg3 = &temp3;
7239   {
7240     try {
7241       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7242     } catch (std::out_of_range& e) {
7243       {
7244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7245       };
7246     } catch (std::exception& e) {
7247       {
7248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7249       };
7250     } catch (Dali::DaliException e) {
7251       {
7252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7253       };
7254     } catch (...) {
7255       {
7256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7257       };
7258     }
7259   }
7260
7261   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7262   return jresult;
7263 }
7264
7265
7266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7267   void * jresult ;
7268   Dali::Vector4 *result = 0 ;
7269
7270   {
7271     try {
7272       result = (Dali::Vector4 *)new Dali::Vector4();
7273     } catch (std::out_of_range& e) {
7274       {
7275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7276       };
7277     } catch (std::exception& e) {
7278       {
7279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7280       };
7281     } catch (Dali::DaliException e) {
7282       {
7283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7284       };
7285     } catch (...) {
7286       {
7287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7288       };
7289     }
7290   }
7291
7292   jresult = (void *)result;
7293   return jresult;
7294 }
7295
7296
7297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7298   void * jresult ;
7299   float arg1 ;
7300   float arg2 ;
7301   float arg3 ;
7302   float arg4 ;
7303   Dali::Vector4 *result = 0 ;
7304
7305   arg1 = (float)jarg1;
7306   arg2 = (float)jarg2;
7307   arg3 = (float)jarg3;
7308   arg4 = (float)jarg4;
7309   {
7310     try {
7311       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7312     } catch (std::out_of_range& e) {
7313       {
7314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7315       };
7316     } catch (std::exception& e) {
7317       {
7318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7319       };
7320     } catch (Dali::DaliException e) {
7321       {
7322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7323       };
7324     } catch (...) {
7325       {
7326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7327       };
7328     }
7329   }
7330
7331   jresult = (void *)result;
7332   return jresult;
7333 }
7334
7335
7336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7337   void * jresult ;
7338   float *arg1 = (float *) 0 ;
7339   Dali::Vector4 *result = 0 ;
7340
7341   arg1 = jarg1;
7342   {
7343     try {
7344       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7345     } catch (std::out_of_range& e) {
7346       {
7347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7348       };
7349     } catch (std::exception& e) {
7350       {
7351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7352       };
7353     } catch (Dali::DaliException e) {
7354       {
7355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7356       };
7357     } catch (...) {
7358       {
7359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7360       };
7361     }
7362   }
7363
7364   jresult = (void *)result;
7365
7366
7367   return jresult;
7368 }
7369
7370
7371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7372   void * jresult ;
7373   Dali::Vector2 *arg1 = 0 ;
7374   Dali::Vector4 *result = 0 ;
7375
7376   arg1 = (Dali::Vector2 *)jarg1;
7377   if (!arg1) {
7378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7379     return 0;
7380   }
7381   {
7382     try {
7383       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7384     } catch (std::out_of_range& e) {
7385       {
7386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7387       };
7388     } catch (std::exception& e) {
7389       {
7390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7391       };
7392     } catch (Dali::DaliException e) {
7393       {
7394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7395       };
7396     } catch (...) {
7397       {
7398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7399       };
7400     }
7401   }
7402
7403   jresult = (void *)result;
7404   return jresult;
7405 }
7406
7407
7408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7409   void * jresult ;
7410   Dali::Vector3 *arg1 = 0 ;
7411   Dali::Vector4 *result = 0 ;
7412
7413   arg1 = (Dali::Vector3 *)jarg1;
7414   if (!arg1) {
7415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7416     return 0;
7417   }
7418   {
7419     try {
7420       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7421     } catch (std::out_of_range& e) {
7422       {
7423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7424       };
7425     } catch (std::exception& e) {
7426       {
7427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7428       };
7429     } catch (Dali::DaliException e) {
7430       {
7431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7432       };
7433     } catch (...) {
7434       {
7435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7436       };
7437     }
7438   }
7439
7440   jresult = (void *)result;
7441   return jresult;
7442 }
7443
7444
7445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7446   void * jresult ;
7447   Dali::Vector4 *result = 0 ;
7448
7449   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7450   jresult = (void *)result;
7451   return jresult;
7452 }
7453
7454
7455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7456   void * jresult ;
7457   Dali::Vector4 *result = 0 ;
7458
7459   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7460   jresult = (void *)result;
7461   return jresult;
7462 }
7463
7464
7465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7466   void * jresult ;
7467   Dali::Vector4 *result = 0 ;
7468
7469   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7470   jresult = (void *)result;
7471   return jresult;
7472 }
7473
7474
7475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7476   void * jresult ;
7477   Dali::Vector4 *result = 0 ;
7478
7479   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7480   jresult = (void *)result;
7481   return jresult;
7482 }
7483
7484
7485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7486   void * jresult ;
7487   Dali::Vector4 *result = 0 ;
7488
7489   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7490   jresult = (void *)result;
7491   return jresult;
7492 }
7493
7494
7495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7496   void * jresult ;
7497   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7498   float *arg2 = (float *) 0 ;
7499   Dali::Vector4 *result = 0 ;
7500
7501   arg1 = (Dali::Vector4 *)jarg1;
7502   arg2 = jarg2;
7503   {
7504     try {
7505       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7506     } catch (std::out_of_range& e) {
7507       {
7508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7509       };
7510     } catch (std::exception& e) {
7511       {
7512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7513       };
7514     } catch (Dali::DaliException e) {
7515       {
7516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7517       };
7518     } catch (...) {
7519       {
7520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7521       };
7522     }
7523   }
7524
7525   jresult = (void *)result;
7526
7527
7528   return jresult;
7529 }
7530
7531
7532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7533   void * jresult ;
7534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7535   Dali::Vector2 *arg2 = 0 ;
7536   Dali::Vector4 *result = 0 ;
7537
7538   arg1 = (Dali::Vector4 *)jarg1;
7539   arg2 = (Dali::Vector2 *)jarg2;
7540   if (!arg2) {
7541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7542     return 0;
7543   }
7544   {
7545     try {
7546       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7547     } catch (std::out_of_range& e) {
7548       {
7549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7550       };
7551     } catch (std::exception& e) {
7552       {
7553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7554       };
7555     } catch (Dali::DaliException e) {
7556       {
7557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7558       };
7559     } catch (...) {
7560       {
7561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7562       };
7563     }
7564   }
7565
7566   jresult = (void *)result;
7567   return jresult;
7568 }
7569
7570
7571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7572   void * jresult ;
7573   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7574   Dali::Vector3 *arg2 = 0 ;
7575   Dali::Vector4 *result = 0 ;
7576
7577   arg1 = (Dali::Vector4 *)jarg1;
7578   arg2 = (Dali::Vector3 *)jarg2;
7579   if (!arg2) {
7580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7581     return 0;
7582   }
7583   {
7584     try {
7585       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7586     } catch (std::out_of_range& e) {
7587       {
7588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7589       };
7590     } catch (std::exception& e) {
7591       {
7592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7593       };
7594     } catch (Dali::DaliException e) {
7595       {
7596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7597       };
7598     } catch (...) {
7599       {
7600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7601       };
7602     }
7603   }
7604
7605   jresult = (void *)result;
7606   return jresult;
7607 }
7608
7609
7610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7611   void * jresult ;
7612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7613   Dali::Vector4 *arg2 = 0 ;
7614   Dali::Vector4 result;
7615
7616   arg1 = (Dali::Vector4 *)jarg1;
7617   arg2 = (Dali::Vector4 *)jarg2;
7618   if (!arg2) {
7619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7620     return 0;
7621   }
7622   {
7623     try {
7624       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7625     } catch (std::out_of_range& e) {
7626       {
7627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7628       };
7629     } catch (std::exception& e) {
7630       {
7631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7632       };
7633     } catch (Dali::DaliException e) {
7634       {
7635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7636       };
7637     } catch (...) {
7638       {
7639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7640       };
7641     }
7642   }
7643
7644   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7645   return jresult;
7646 }
7647
7648
7649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7650   void * jresult ;
7651   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7652   Dali::Vector4 *arg2 = 0 ;
7653   Dali::Vector4 *result = 0 ;
7654
7655   arg1 = (Dali::Vector4 *)jarg1;
7656   arg2 = (Dali::Vector4 *)jarg2;
7657   if (!arg2) {
7658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7659     return 0;
7660   }
7661   {
7662     try {
7663       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7664     } catch (std::out_of_range& e) {
7665       {
7666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7667       };
7668     } catch (std::exception& e) {
7669       {
7670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7671       };
7672     } catch (Dali::DaliException e) {
7673       {
7674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7675       };
7676     } catch (...) {
7677       {
7678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7679       };
7680     }
7681   }
7682
7683   jresult = (void *)result;
7684   return jresult;
7685 }
7686
7687
7688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7689   void * jresult ;
7690   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7691   Dali::Vector4 *arg2 = 0 ;
7692   Dali::Vector4 result;
7693
7694   arg1 = (Dali::Vector4 *)jarg1;
7695   arg2 = (Dali::Vector4 *)jarg2;
7696   if (!arg2) {
7697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7698     return 0;
7699   }
7700   {
7701     try {
7702       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7703     } catch (std::out_of_range& e) {
7704       {
7705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7706       };
7707     } catch (std::exception& e) {
7708       {
7709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7710       };
7711     } catch (Dali::DaliException e) {
7712       {
7713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7714       };
7715     } catch (...) {
7716       {
7717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7718       };
7719     }
7720   }
7721
7722   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7723   return jresult;
7724 }
7725
7726
7727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7728   void * jresult ;
7729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7730   Dali::Vector4 *arg2 = 0 ;
7731   Dali::Vector4 *result = 0 ;
7732
7733   arg1 = (Dali::Vector4 *)jarg1;
7734   arg2 = (Dali::Vector4 *)jarg2;
7735   if (!arg2) {
7736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7737     return 0;
7738   }
7739   {
7740     try {
7741       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7742     } catch (std::out_of_range& e) {
7743       {
7744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7745       };
7746     } catch (std::exception& e) {
7747       {
7748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7749       };
7750     } catch (Dali::DaliException e) {
7751       {
7752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7753       };
7754     } catch (...) {
7755       {
7756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7757       };
7758     }
7759   }
7760
7761   jresult = (void *)result;
7762   return jresult;
7763 }
7764
7765
7766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7767   void * jresult ;
7768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7769   Dali::Vector4 *arg2 = 0 ;
7770   Dali::Vector4 result;
7771
7772   arg1 = (Dali::Vector4 *)jarg1;
7773   arg2 = (Dali::Vector4 *)jarg2;
7774   if (!arg2) {
7775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7776     return 0;
7777   }
7778   {
7779     try {
7780       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7781     } catch (std::out_of_range& e) {
7782       {
7783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7784       };
7785     } catch (std::exception& e) {
7786       {
7787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7788       };
7789     } catch (Dali::DaliException e) {
7790       {
7791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7792       };
7793     } catch (...) {
7794       {
7795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7796       };
7797     }
7798   }
7799
7800   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7801   return jresult;
7802 }
7803
7804
7805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7806   void * jresult ;
7807   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7808   float arg2 ;
7809   Dali::Vector4 result;
7810
7811   arg1 = (Dali::Vector4 *)jarg1;
7812   arg2 = (float)jarg2;
7813   {
7814     try {
7815       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7816     } catch (std::out_of_range& e) {
7817       {
7818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7819       };
7820     } catch (std::exception& e) {
7821       {
7822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7823       };
7824     } catch (Dali::DaliException e) {
7825       {
7826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7827       };
7828     } catch (...) {
7829       {
7830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7831       };
7832     }
7833   }
7834
7835   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7836   return jresult;
7837 }
7838
7839
7840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7841   void * jresult ;
7842   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7843   Dali::Vector4 *arg2 = 0 ;
7844   Dali::Vector4 *result = 0 ;
7845
7846   arg1 = (Dali::Vector4 *)jarg1;
7847   arg2 = (Dali::Vector4 *)jarg2;
7848   if (!arg2) {
7849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7850     return 0;
7851   }
7852   {
7853     try {
7854       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7855     } catch (std::out_of_range& e) {
7856       {
7857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7858       };
7859     } catch (std::exception& e) {
7860       {
7861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7862       };
7863     } catch (Dali::DaliException e) {
7864       {
7865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7866       };
7867     } catch (...) {
7868       {
7869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7870       };
7871     }
7872   }
7873
7874   jresult = (void *)result;
7875   return jresult;
7876 }
7877
7878
7879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7880   void * jresult ;
7881   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7882   float arg2 ;
7883   Dali::Vector4 *result = 0 ;
7884
7885   arg1 = (Dali::Vector4 *)jarg1;
7886   arg2 = (float)jarg2;
7887   {
7888     try {
7889       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7890     } catch (std::out_of_range& e) {
7891       {
7892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7893       };
7894     } catch (std::exception& e) {
7895       {
7896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7897       };
7898     } catch (Dali::DaliException e) {
7899       {
7900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7901       };
7902     } catch (...) {
7903       {
7904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7905       };
7906     }
7907   }
7908
7909   jresult = (void *)result;
7910   return jresult;
7911 }
7912
7913
7914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7915   void * jresult ;
7916   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7917   Dali::Vector4 *arg2 = 0 ;
7918   Dali::Vector4 result;
7919
7920   arg1 = (Dali::Vector4 *)jarg1;
7921   arg2 = (Dali::Vector4 *)jarg2;
7922   if (!arg2) {
7923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7924     return 0;
7925   }
7926   {
7927     try {
7928       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7929     } catch (std::out_of_range& e) {
7930       {
7931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7932       };
7933     } catch (std::exception& e) {
7934       {
7935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7936       };
7937     } catch (Dali::DaliException e) {
7938       {
7939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7940       };
7941     } catch (...) {
7942       {
7943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7944       };
7945     }
7946   }
7947
7948   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7949   return jresult;
7950 }
7951
7952
7953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7954   void * jresult ;
7955   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7956   float arg2 ;
7957   Dali::Vector4 result;
7958
7959   arg1 = (Dali::Vector4 *)jarg1;
7960   arg2 = (float)jarg2;
7961   {
7962     try {
7963       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7964     } catch (std::out_of_range& e) {
7965       {
7966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7967       };
7968     } catch (std::exception& e) {
7969       {
7970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7971       };
7972     } catch (Dali::DaliException e) {
7973       {
7974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7975       };
7976     } catch (...) {
7977       {
7978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7979       };
7980     }
7981   }
7982
7983   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7984   return jresult;
7985 }
7986
7987
7988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7989   void * jresult ;
7990   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7991   Dali::Vector4 *arg2 = 0 ;
7992   Dali::Vector4 *result = 0 ;
7993
7994   arg1 = (Dali::Vector4 *)jarg1;
7995   arg2 = (Dali::Vector4 *)jarg2;
7996   if (!arg2) {
7997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7998     return 0;
7999   }
8000   {
8001     try {
8002       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8003     } catch (std::out_of_range& e) {
8004       {
8005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8006       };
8007     } catch (std::exception& e) {
8008       {
8009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8010       };
8011     } catch (Dali::DaliException e) {
8012       {
8013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8014       };
8015     } catch (...) {
8016       {
8017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8018       };
8019     }
8020   }
8021
8022   jresult = (void *)result;
8023   return jresult;
8024 }
8025
8026
8027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8028   void * jresult ;
8029   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8030   float arg2 ;
8031   Dali::Vector4 *result = 0 ;
8032
8033   arg1 = (Dali::Vector4 *)jarg1;
8034   arg2 = (float)jarg2;
8035   {
8036     try {
8037       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8038     } catch (std::out_of_range& e) {
8039       {
8040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8041       };
8042     } catch (std::exception& e) {
8043       {
8044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8045       };
8046     } catch (Dali::DaliException e) {
8047       {
8048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8049       };
8050     } catch (...) {
8051       {
8052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8053       };
8054     }
8055   }
8056
8057   jresult = (void *)result;
8058   return jresult;
8059 }
8060
8061
8062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8063   void * jresult ;
8064   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8065   Dali::Vector4 result;
8066
8067   arg1 = (Dali::Vector4 *)jarg1;
8068   {
8069     try {
8070       result = ((Dali::Vector4 const *)arg1)->operator -();
8071     } catch (std::out_of_range& e) {
8072       {
8073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8074       };
8075     } catch (std::exception& e) {
8076       {
8077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8078       };
8079     } catch (Dali::DaliException e) {
8080       {
8081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8082       };
8083     } catch (...) {
8084       {
8085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8086       };
8087     }
8088   }
8089
8090   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8091   return jresult;
8092 }
8093
8094
8095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8096   unsigned int jresult ;
8097   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8098   Dali::Vector4 *arg2 = 0 ;
8099   bool result;
8100
8101   arg1 = (Dali::Vector4 *)jarg1;
8102   arg2 = (Dali::Vector4 *)jarg2;
8103   if (!arg2) {
8104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8105     return 0;
8106   }
8107   {
8108     try {
8109       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8110     } catch (std::out_of_range& e) {
8111       {
8112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8113       };
8114     } catch (std::exception& e) {
8115       {
8116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8117       };
8118     } catch (Dali::DaliException e) {
8119       {
8120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8121       };
8122     } catch (...) {
8123       {
8124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8125       };
8126     }
8127   }
8128
8129   jresult = result;
8130   return jresult;
8131 }
8132
8133
8134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8135   unsigned int jresult ;
8136   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8137   Dali::Vector4 *arg2 = 0 ;
8138   bool result;
8139
8140   arg1 = (Dali::Vector4 *)jarg1;
8141   arg2 = (Dali::Vector4 *)jarg2;
8142   if (!arg2) {
8143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8144     return 0;
8145   }
8146   {
8147     try {
8148       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8149     } catch (std::out_of_range& e) {
8150       {
8151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8152       };
8153     } catch (std::exception& e) {
8154       {
8155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8156       };
8157     } catch (Dali::DaliException e) {
8158       {
8159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8160       };
8161     } catch (...) {
8162       {
8163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8164       };
8165     }
8166   }
8167
8168   jresult = result;
8169   return jresult;
8170 }
8171
8172
8173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8174   float jresult ;
8175   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8176   unsigned int arg2 ;
8177   float *result = 0 ;
8178
8179   arg1 = (Dali::Vector4 *)jarg1;
8180   arg2 = (unsigned int)jarg2;
8181   {
8182     try {
8183       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8184     } catch (std::out_of_range& e) {
8185       {
8186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8187       };
8188     } catch (std::exception& e) {
8189       {
8190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8191       };
8192     } catch (Dali::DaliException e) {
8193       {
8194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8195       };
8196     } catch (...) {
8197       {
8198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8199       };
8200     }
8201   }
8202
8203   jresult = *result;
8204   return jresult;
8205 }
8206
8207
8208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8209   float jresult ;
8210   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8211   Dali::Vector3 *arg2 = 0 ;
8212   float result;
8213
8214   arg1 = (Dali::Vector4 *)jarg1;
8215   arg2 = (Dali::Vector3 *)jarg2;
8216   if (!arg2) {
8217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8218     return 0;
8219   }
8220   {
8221     try {
8222       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8223     } catch (std::out_of_range& e) {
8224       {
8225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8226       };
8227     } catch (std::exception& e) {
8228       {
8229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8230       };
8231     } catch (Dali::DaliException e) {
8232       {
8233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8234       };
8235     } catch (...) {
8236       {
8237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8238       };
8239     }
8240   }
8241
8242   jresult = result;
8243   return jresult;
8244 }
8245
8246
8247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8248   float jresult ;
8249   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8250   Dali::Vector4 *arg2 = 0 ;
8251   float result;
8252
8253   arg1 = (Dali::Vector4 *)jarg1;
8254   arg2 = (Dali::Vector4 *)jarg2;
8255   if (!arg2) {
8256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8257     return 0;
8258   }
8259   {
8260     try {
8261       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8262     } catch (std::out_of_range& e) {
8263       {
8264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8265       };
8266     } catch (std::exception& e) {
8267       {
8268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8269       };
8270     } catch (Dali::DaliException e) {
8271       {
8272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8273       };
8274     } catch (...) {
8275       {
8276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8277       };
8278     }
8279   }
8280
8281   jresult = result;
8282   return jresult;
8283 }
8284
8285
8286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8287   float jresult ;
8288   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8289   Dali::Vector4 *arg2 = 0 ;
8290   float result;
8291
8292   arg1 = (Dali::Vector4 *)jarg1;
8293   arg2 = (Dali::Vector4 *)jarg2;
8294   if (!arg2) {
8295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8296     return 0;
8297   }
8298   {
8299     try {
8300       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8301     } catch (std::out_of_range& e) {
8302       {
8303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8304       };
8305     } catch (std::exception& e) {
8306       {
8307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8308       };
8309     } catch (Dali::DaliException e) {
8310       {
8311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8312       };
8313     } catch (...) {
8314       {
8315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8316       };
8317     }
8318   }
8319
8320   jresult = result;
8321   return jresult;
8322 }
8323
8324
8325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8326   void * jresult ;
8327   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8328   Dali::Vector4 *arg2 = 0 ;
8329   Dali::Vector4 result;
8330
8331   arg1 = (Dali::Vector4 *)jarg1;
8332   arg2 = (Dali::Vector4 *)jarg2;
8333   if (!arg2) {
8334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8335     return 0;
8336   }
8337   {
8338     try {
8339       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8340     } catch (std::out_of_range& e) {
8341       {
8342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8343       };
8344     } catch (std::exception& e) {
8345       {
8346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8347       };
8348     } catch (Dali::DaliException e) {
8349       {
8350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8351       };
8352     } catch (...) {
8353       {
8354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8355       };
8356     }
8357   }
8358
8359   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8360   return jresult;
8361 }
8362
8363
8364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8365   float jresult ;
8366   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8367   float result;
8368
8369   arg1 = (Dali::Vector4 *)jarg1;
8370   {
8371     try {
8372       result = (float)((Dali::Vector4 const *)arg1)->Length();
8373     } catch (std::out_of_range& e) {
8374       {
8375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8376       };
8377     } catch (std::exception& e) {
8378       {
8379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8380       };
8381     } catch (Dali::DaliException e) {
8382       {
8383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8384       };
8385     } catch (...) {
8386       {
8387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8388       };
8389     }
8390   }
8391
8392   jresult = result;
8393   return jresult;
8394 }
8395
8396
8397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8398   float jresult ;
8399   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8400   float result;
8401
8402   arg1 = (Dali::Vector4 *)jarg1;
8403   {
8404     try {
8405       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8406     } catch (std::out_of_range& e) {
8407       {
8408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8409       };
8410     } catch (std::exception& e) {
8411       {
8412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8413       };
8414     } catch (Dali::DaliException e) {
8415       {
8416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8417       };
8418     } catch (...) {
8419       {
8420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8421       };
8422     }
8423   }
8424
8425   jresult = result;
8426   return jresult;
8427 }
8428
8429
8430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8431   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8432
8433   arg1 = (Dali::Vector4 *)jarg1;
8434   {
8435     try {
8436       (arg1)->Normalize();
8437     } catch (std::out_of_range& e) {
8438       {
8439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8440       };
8441     } catch (std::exception& e) {
8442       {
8443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8444       };
8445     } catch (Dali::DaliException e) {
8446       {
8447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8448       };
8449     } catch (...) {
8450       {
8451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8452       };
8453     }
8454   }
8455
8456 }
8457
8458
8459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8460   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8461   Dali::Vector4 *arg2 = 0 ;
8462   Dali::Vector4 *arg3 = 0 ;
8463
8464   arg1 = (Dali::Vector4 *)jarg1;
8465   arg2 = (Dali::Vector4 *)jarg2;
8466   if (!arg2) {
8467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8468     return ;
8469   }
8470   arg3 = (Dali::Vector4 *)jarg3;
8471   if (!arg3) {
8472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8473     return ;
8474   }
8475   {
8476     try {
8477       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8478     } catch (std::out_of_range& e) {
8479       {
8480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8481       };
8482     } catch (std::exception& e) {
8483       {
8484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8485       };
8486     } catch (Dali::DaliException e) {
8487       {
8488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8489       };
8490     } catch (...) {
8491       {
8492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8493       };
8494     }
8495   }
8496
8497 }
8498
8499
8500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8501   void * jresult ;
8502   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8503   float *result = 0 ;
8504
8505   arg1 = (Dali::Vector4 *)jarg1;
8506   {
8507     try {
8508       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8509     } catch (std::out_of_range& e) {
8510       {
8511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8512       };
8513     } catch (std::exception& e) {
8514       {
8515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8516       };
8517     } catch (Dali::DaliException e) {
8518       {
8519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8520       };
8521     } catch (...) {
8522       {
8523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8524       };
8525     }
8526   }
8527
8528   jresult = (void *)result;
8529   return jresult;
8530 }
8531
8532
8533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8535   float arg2 ;
8536
8537   arg1 = (Dali::Vector4 *)jarg1;
8538   arg2 = (float)jarg2;
8539   if (arg1) (arg1)->x = arg2;
8540 }
8541
8542
8543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8544   float jresult ;
8545   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8546   float result;
8547
8548   arg1 = (Dali::Vector4 *)jarg1;
8549   result = (float) ((arg1)->x);
8550   jresult = result;
8551   return jresult;
8552 }
8553
8554
8555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8556   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8557   float arg2 ;
8558
8559   arg1 = (Dali::Vector4 *)jarg1;
8560   arg2 = (float)jarg2;
8561   if (arg1) (arg1)->r = arg2;
8562 }
8563
8564
8565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8566   float jresult ;
8567   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8568   float result;
8569
8570   arg1 = (Dali::Vector4 *)jarg1;
8571   result = (float) ((arg1)->r);
8572   jresult = result;
8573   return jresult;
8574 }
8575
8576
8577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8578   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8579   float arg2 ;
8580
8581   arg1 = (Dali::Vector4 *)jarg1;
8582   arg2 = (float)jarg2;
8583   if (arg1) (arg1)->s = arg2;
8584 }
8585
8586
8587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8588   float jresult ;
8589   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8590   float result;
8591
8592   arg1 = (Dali::Vector4 *)jarg1;
8593   result = (float) ((arg1)->s);
8594   jresult = result;
8595   return jresult;
8596 }
8597
8598
8599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8600   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8601   float arg2 ;
8602
8603   arg1 = (Dali::Vector4 *)jarg1;
8604   arg2 = (float)jarg2;
8605   if (arg1) (arg1)->y = arg2;
8606 }
8607
8608
8609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8610   float jresult ;
8611   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8612   float result;
8613
8614   arg1 = (Dali::Vector4 *)jarg1;
8615   result = (float) ((arg1)->y);
8616   jresult = result;
8617   return jresult;
8618 }
8619
8620
8621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8622   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8623   float arg2 ;
8624
8625   arg1 = (Dali::Vector4 *)jarg1;
8626   arg2 = (float)jarg2;
8627   if (arg1) (arg1)->g = arg2;
8628 }
8629
8630
8631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8632   float jresult ;
8633   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8634   float result;
8635
8636   arg1 = (Dali::Vector4 *)jarg1;
8637   result = (float) ((arg1)->g);
8638   jresult = result;
8639   return jresult;
8640 }
8641
8642
8643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8644   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8645   float arg2 ;
8646
8647   arg1 = (Dali::Vector4 *)jarg1;
8648   arg2 = (float)jarg2;
8649   if (arg1) (arg1)->t = arg2;
8650 }
8651
8652
8653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8654   float jresult ;
8655   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8656   float result;
8657
8658   arg1 = (Dali::Vector4 *)jarg1;
8659   result = (float) ((arg1)->t);
8660   jresult = result;
8661   return jresult;
8662 }
8663
8664
8665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8666   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8667   float arg2 ;
8668
8669   arg1 = (Dali::Vector4 *)jarg1;
8670   arg2 = (float)jarg2;
8671   if (arg1) (arg1)->z = arg2;
8672 }
8673
8674
8675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8676   float jresult ;
8677   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8678   float result;
8679
8680   arg1 = (Dali::Vector4 *)jarg1;
8681   result = (float) ((arg1)->z);
8682   jresult = result;
8683   return jresult;
8684 }
8685
8686
8687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8688   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8689   float arg2 ;
8690
8691   arg1 = (Dali::Vector4 *)jarg1;
8692   arg2 = (float)jarg2;
8693   if (arg1) (arg1)->b = arg2;
8694 }
8695
8696
8697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8698   float jresult ;
8699   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8700   float result;
8701
8702   arg1 = (Dali::Vector4 *)jarg1;
8703   result = (float) ((arg1)->b);
8704   jresult = result;
8705   return jresult;
8706 }
8707
8708
8709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8710   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8711   float arg2 ;
8712
8713   arg1 = (Dali::Vector4 *)jarg1;
8714   arg2 = (float)jarg2;
8715   if (arg1) (arg1)->p = arg2;
8716 }
8717
8718
8719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8720   float jresult ;
8721   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8722   float result;
8723
8724   arg1 = (Dali::Vector4 *)jarg1;
8725   result = (float) ((arg1)->p);
8726   jresult = result;
8727   return jresult;
8728 }
8729
8730
8731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8733   float arg2 ;
8734
8735   arg1 = (Dali::Vector4 *)jarg1;
8736   arg2 = (float)jarg2;
8737   if (arg1) (arg1)->w = arg2;
8738 }
8739
8740
8741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8742   float jresult ;
8743   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8744   float result;
8745
8746   arg1 = (Dali::Vector4 *)jarg1;
8747   result = (float) ((arg1)->w);
8748   jresult = result;
8749   return jresult;
8750 }
8751
8752
8753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8754   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8755   float arg2 ;
8756
8757   arg1 = (Dali::Vector4 *)jarg1;
8758   arg2 = (float)jarg2;
8759   if (arg1) (arg1)->a = arg2;
8760 }
8761
8762
8763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8764   float jresult ;
8765   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8766   float result;
8767
8768   arg1 = (Dali::Vector4 *)jarg1;
8769   result = (float) ((arg1)->a);
8770   jresult = result;
8771   return jresult;
8772 }
8773
8774
8775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8776   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8777   float arg2 ;
8778
8779   arg1 = (Dali::Vector4 *)jarg1;
8780   arg2 = (float)jarg2;
8781   if (arg1) (arg1)->q = arg2;
8782 }
8783
8784
8785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8786   float jresult ;
8787   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8788   float result;
8789
8790   arg1 = (Dali::Vector4 *)jarg1;
8791   result = (float) ((arg1)->q);
8792   jresult = result;
8793   return jresult;
8794 }
8795
8796
8797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8798   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8799
8800   arg1 = (Dali::Vector4 *)jarg1;
8801   {
8802     try {
8803       delete arg1;
8804     } catch (std::out_of_range& e) {
8805       {
8806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8807       };
8808     } catch (std::exception& e) {
8809       {
8810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8811       };
8812     } catch (Dali::DaliException e) {
8813       {
8814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8815       };
8816     } catch (...) {
8817       {
8818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8819       };
8820     }
8821   }
8822
8823 }
8824
8825
8826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8827   void * jresult ;
8828   Dali::Vector4 *arg1 = 0 ;
8829   Dali::Vector4 *arg2 = 0 ;
8830   Dali::Vector4 result;
8831
8832   arg1 = (Dali::Vector4 *)jarg1;
8833   if (!arg1) {
8834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8835     return 0;
8836   }
8837   arg2 = (Dali::Vector4 *)jarg2;
8838   if (!arg2) {
8839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8840     return 0;
8841   }
8842   {
8843     try {
8844       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8845     } catch (std::out_of_range& e) {
8846       {
8847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8848       };
8849     } catch (std::exception& e) {
8850       {
8851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8852       };
8853     } catch (Dali::DaliException e) {
8854       {
8855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8856       };
8857     } catch (...) {
8858       {
8859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8860       };
8861     }
8862   }
8863
8864   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8865   return jresult;
8866 }
8867
8868
8869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8870   void * jresult ;
8871   Dali::Vector4 *arg1 = 0 ;
8872   Dali::Vector4 *arg2 = 0 ;
8873   Dali::Vector4 result;
8874
8875   arg1 = (Dali::Vector4 *)jarg1;
8876   if (!arg1) {
8877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8878     return 0;
8879   }
8880   arg2 = (Dali::Vector4 *)jarg2;
8881   if (!arg2) {
8882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8883     return 0;
8884   }
8885   {
8886     try {
8887       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8888     } catch (std::out_of_range& e) {
8889       {
8890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8891       };
8892     } catch (std::exception& e) {
8893       {
8894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8895       };
8896     } catch (Dali::DaliException e) {
8897       {
8898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8899       };
8900     } catch (...) {
8901       {
8902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8903       };
8904     }
8905   }
8906
8907   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8908   return jresult;
8909 }
8910
8911
8912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8913   void * jresult ;
8914   Dali::Vector4 *arg1 = 0 ;
8915   float *arg2 = 0 ;
8916   float *arg3 = 0 ;
8917   float temp2 ;
8918   float temp3 ;
8919   Dali::Vector4 result;
8920
8921   arg1 = (Dali::Vector4 *)jarg1;
8922   if (!arg1) {
8923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8924     return 0;
8925   }
8926   temp2 = (float)jarg2;
8927   arg2 = &temp2;
8928   temp3 = (float)jarg3;
8929   arg3 = &temp3;
8930   {
8931     try {
8932       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8933     } catch (std::out_of_range& e) {
8934       {
8935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8936       };
8937     } catch (std::exception& e) {
8938       {
8939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8940       };
8941     } catch (Dali::DaliException e) {
8942       {
8943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8944       };
8945     } catch (...) {
8946       {
8947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8948       };
8949     }
8950   }
8951
8952   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8953   return jresult;
8954 }
8955
8956
8957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8958   void * jresult ;
8959   Dali::Uint16Pair *result = 0 ;
8960
8961   {
8962     try {
8963       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8964     } catch (std::out_of_range& e) {
8965       {
8966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8967       };
8968     } catch (std::exception& e) {
8969       {
8970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8971       };
8972     } catch (Dali::DaliException e) {
8973       {
8974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8975       };
8976     } catch (...) {
8977       {
8978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8979       };
8980     }
8981   }
8982
8983   jresult = (void *)result;
8984   return jresult;
8985 }
8986
8987
8988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8989   void * jresult ;
8990   uint32_t arg1 ;
8991   uint32_t arg2 ;
8992   Dali::Uint16Pair *result = 0 ;
8993
8994   arg1 = (uint32_t)jarg1;
8995   arg2 = (uint32_t)jarg2;
8996   {
8997     try {
8998       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8999     } catch (std::out_of_range& e) {
9000       {
9001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9002       };
9003     } catch (std::exception& e) {
9004       {
9005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9006       };
9007     } catch (Dali::DaliException e) {
9008       {
9009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9010       };
9011     } catch (...) {
9012       {
9013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9014       };
9015     }
9016   }
9017
9018   jresult = (void *)result;
9019   return jresult;
9020 }
9021
9022
9023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9024   void * jresult ;
9025   Dali::Uint16Pair *arg1 = 0 ;
9026   Dali::Uint16Pair *result = 0 ;
9027
9028   arg1 = (Dali::Uint16Pair *)jarg1;
9029   if (!arg1) {
9030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9031     return 0;
9032   }
9033   {
9034     try {
9035       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9036     } catch (std::out_of_range& e) {
9037       {
9038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9039       };
9040     } catch (std::exception& e) {
9041       {
9042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9043       };
9044     } catch (Dali::DaliException e) {
9045       {
9046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9047       };
9048     } catch (...) {
9049       {
9050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9051       };
9052     }
9053   }
9054
9055   jresult = (void *)result;
9056   return jresult;
9057 }
9058
9059
9060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9061   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9062   uint16_t arg2 ;
9063
9064   arg1 = (Dali::Uint16Pair *)jarg1;
9065   arg2 = (uint16_t)jarg2;
9066   {
9067     try {
9068       (arg1)->SetWidth(arg2);
9069     } catch (std::out_of_range& e) {
9070       {
9071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9072       };
9073     } catch (std::exception& e) {
9074       {
9075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9076       };
9077     } catch (Dali::DaliException e) {
9078       {
9079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9080       };
9081     } catch (...) {
9082       {
9083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9084       };
9085     }
9086   }
9087
9088 }
9089
9090
9091 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9092   unsigned short jresult ;
9093   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9094   uint16_t result;
9095
9096   arg1 = (Dali::Uint16Pair *)jarg1;
9097   {
9098     try {
9099       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9100     } catch (std::out_of_range& e) {
9101       {
9102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9103       };
9104     } catch (std::exception& e) {
9105       {
9106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9107       };
9108     } catch (Dali::DaliException e) {
9109       {
9110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9111       };
9112     } catch (...) {
9113       {
9114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9115       };
9116     }
9117   }
9118
9119   jresult = result;
9120   return jresult;
9121 }
9122
9123
9124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9125   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9126   uint16_t arg2 ;
9127
9128   arg1 = (Dali::Uint16Pair *)jarg1;
9129   arg2 = (uint16_t)jarg2;
9130   {
9131     try {
9132       (arg1)->SetHeight(arg2);
9133     } catch (std::out_of_range& e) {
9134       {
9135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9136       };
9137     } catch (std::exception& e) {
9138       {
9139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9140       };
9141     } catch (Dali::DaliException e) {
9142       {
9143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9144       };
9145     } catch (...) {
9146       {
9147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9148       };
9149     }
9150   }
9151
9152 }
9153
9154
9155 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9156   unsigned short jresult ;
9157   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9158   uint16_t result;
9159
9160   arg1 = (Dali::Uint16Pair *)jarg1;
9161   {
9162     try {
9163       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9164     } catch (std::out_of_range& e) {
9165       {
9166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9167       };
9168     } catch (std::exception& e) {
9169       {
9170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9171       };
9172     } catch (Dali::DaliException e) {
9173       {
9174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9175       };
9176     } catch (...) {
9177       {
9178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9179       };
9180     }
9181   }
9182
9183   jresult = result;
9184   return jresult;
9185 }
9186
9187
9188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9189   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9190   uint16_t arg2 ;
9191
9192   arg1 = (Dali::Uint16Pair *)jarg1;
9193   arg2 = (uint16_t)jarg2;
9194   {
9195     try {
9196       (arg1)->SetX(arg2);
9197     } catch (std::out_of_range& e) {
9198       {
9199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9200       };
9201     } catch (std::exception& e) {
9202       {
9203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9204       };
9205     } catch (Dali::DaliException e) {
9206       {
9207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9208       };
9209     } catch (...) {
9210       {
9211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9212       };
9213     }
9214   }
9215
9216 }
9217
9218
9219 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9220   unsigned short jresult ;
9221   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9222   uint16_t result;
9223
9224   arg1 = (Dali::Uint16Pair *)jarg1;
9225   {
9226     try {
9227       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9228     } catch (std::out_of_range& e) {
9229       {
9230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9231       };
9232     } catch (std::exception& e) {
9233       {
9234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9235       };
9236     } catch (Dali::DaliException e) {
9237       {
9238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9239       };
9240     } catch (...) {
9241       {
9242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9243       };
9244     }
9245   }
9246
9247   jresult = result;
9248   return jresult;
9249 }
9250
9251
9252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9253   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9254   uint16_t arg2 ;
9255
9256   arg1 = (Dali::Uint16Pair *)jarg1;
9257   arg2 = (uint16_t)jarg2;
9258   {
9259     try {
9260       (arg1)->SetY(arg2);
9261     } catch (std::out_of_range& e) {
9262       {
9263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9264       };
9265     } catch (std::exception& e) {
9266       {
9267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9268       };
9269     } catch (Dali::DaliException e) {
9270       {
9271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9272       };
9273     } catch (...) {
9274       {
9275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9276       };
9277     }
9278   }
9279
9280 }
9281
9282
9283 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9284   unsigned short jresult ;
9285   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9286   uint16_t result;
9287
9288   arg1 = (Dali::Uint16Pair *)jarg1;
9289   {
9290     try {
9291       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9292     } catch (std::out_of_range& e) {
9293       {
9294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9295       };
9296     } catch (std::exception& e) {
9297       {
9298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9299       };
9300     } catch (Dali::DaliException e) {
9301       {
9302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9303       };
9304     } catch (...) {
9305       {
9306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9307       };
9308     }
9309   }
9310
9311   jresult = result;
9312   return jresult;
9313 }
9314
9315
9316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9317   void * jresult ;
9318   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9319   Dali::Uint16Pair *arg2 = 0 ;
9320   Dali::Uint16Pair *result = 0 ;
9321
9322   arg1 = (Dali::Uint16Pair *)jarg1;
9323   arg2 = (Dali::Uint16Pair *)jarg2;
9324   if (!arg2) {
9325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9326     return 0;
9327   }
9328   {
9329     try {
9330       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9331     } catch (std::out_of_range& e) {
9332       {
9333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9334       };
9335     } catch (std::exception& e) {
9336       {
9337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9338       };
9339     } catch (Dali::DaliException e) {
9340       {
9341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9342       };
9343     } catch (...) {
9344       {
9345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9346       };
9347     }
9348   }
9349
9350   jresult = (void *)result;
9351   return jresult;
9352 }
9353
9354
9355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9356   unsigned int jresult ;
9357   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9358   Dali::Uint16Pair *arg2 = 0 ;
9359   bool result;
9360
9361   arg1 = (Dali::Uint16Pair *)jarg1;
9362   arg2 = (Dali::Uint16Pair *)jarg2;
9363   if (!arg2) {
9364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9365     return 0;
9366   }
9367   {
9368     try {
9369       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9370     } catch (std::out_of_range& e) {
9371       {
9372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9373       };
9374     } catch (std::exception& e) {
9375       {
9376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9377       };
9378     } catch (Dali::DaliException e) {
9379       {
9380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9381       };
9382     } catch (...) {
9383       {
9384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9385       };
9386     }
9387   }
9388
9389   jresult = result;
9390   return jresult;
9391 }
9392
9393
9394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9395   unsigned int jresult ;
9396   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9397   Dali::Uint16Pair *arg2 = 0 ;
9398   bool result;
9399
9400   arg1 = (Dali::Uint16Pair *)jarg1;
9401   arg2 = (Dali::Uint16Pair *)jarg2;
9402   if (!arg2) {
9403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9404     return 0;
9405   }
9406   {
9407     try {
9408       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9409     } catch (std::out_of_range& e) {
9410       {
9411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9412       };
9413     } catch (std::exception& e) {
9414       {
9415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9416       };
9417     } catch (Dali::DaliException e) {
9418       {
9419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9420       };
9421     } catch (...) {
9422       {
9423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9424       };
9425     }
9426   }
9427
9428   jresult = result;
9429   return jresult;
9430 }
9431
9432
9433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9434   unsigned int jresult ;
9435   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9436   Dali::Uint16Pair *arg2 = 0 ;
9437   bool result;
9438
9439   arg1 = (Dali::Uint16Pair *)jarg1;
9440   arg2 = (Dali::Uint16Pair *)jarg2;
9441   if (!arg2) {
9442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9443     return 0;
9444   }
9445   {
9446     try {
9447       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9448     } catch (std::out_of_range& e) {
9449       {
9450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9451       };
9452     } catch (std::exception& e) {
9453       {
9454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9455       };
9456     } catch (Dali::DaliException e) {
9457       {
9458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9459       };
9460     } catch (...) {
9461       {
9462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9463       };
9464     }
9465   }
9466
9467   jresult = result;
9468   return jresult;
9469 }
9470
9471
9472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9473   unsigned int jresult ;
9474   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9475   Dali::Uint16Pair *arg2 = 0 ;
9476   bool result;
9477
9478   arg1 = (Dali::Uint16Pair *)jarg1;
9479   arg2 = (Dali::Uint16Pair *)jarg2;
9480   if (!arg2) {
9481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9482     return 0;
9483   }
9484   {
9485     try {
9486       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9487     } catch (std::out_of_range& e) {
9488       {
9489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9490       };
9491     } catch (std::exception& e) {
9492       {
9493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9494       };
9495     } catch (Dali::DaliException e) {
9496       {
9497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9498       };
9499     } catch (...) {
9500       {
9501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9502       };
9503     }
9504   }
9505
9506   jresult = result;
9507   return jresult;
9508 }
9509
9510
9511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9512   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9513
9514   arg1 = (Dali::Uint16Pair *)jarg1;
9515   {
9516     try {
9517       delete arg1;
9518     } catch (std::out_of_range& e) {
9519       {
9520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9521       };
9522     } catch (std::exception& e) {
9523       {
9524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9525       };
9526     } catch (Dali::DaliException e) {
9527       {
9528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9529       };
9530     } catch (...) {
9531       {
9532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9533       };
9534     }
9535   }
9536
9537 }
9538
9539
9540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9541   void * jresult ;
9542   Dali::Degree *result = 0 ;
9543
9544   {
9545     try {
9546       result = (Dali::Degree *)new Dali::Degree();
9547     } catch (std::out_of_range& e) {
9548       {
9549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9550       };
9551     } catch (std::exception& e) {
9552       {
9553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9554       };
9555     } catch (Dali::DaliException e) {
9556       {
9557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9558       };
9559     } catch (...) {
9560       {
9561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9562       };
9563     }
9564   }
9565
9566   jresult = (void *)result;
9567   return jresult;
9568 }
9569
9570
9571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9572   void * jresult ;
9573   float arg1 ;
9574   Dali::Degree *result = 0 ;
9575
9576   arg1 = (float)jarg1;
9577   {
9578     try {
9579       result = (Dali::Degree *)new Dali::Degree(arg1);
9580     } catch (std::out_of_range& e) {
9581       {
9582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9583       };
9584     } catch (std::exception& e) {
9585       {
9586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9587       };
9588     } catch (Dali::DaliException e) {
9589       {
9590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9591       };
9592     } catch (...) {
9593       {
9594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9595       };
9596     }
9597   }
9598
9599   jresult = (void *)result;
9600   return jresult;
9601 }
9602
9603
9604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9605   void * jresult ;
9606   Dali::Radian arg1 ;
9607   Dali::Radian *argp1 ;
9608   Dali::Degree *result = 0 ;
9609
9610   argp1 = (Dali::Radian *)jarg1;
9611   if (!argp1) {
9612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9613     return 0;
9614   }
9615   arg1 = *argp1;
9616   {
9617     try {
9618       result = (Dali::Degree *)new Dali::Degree(arg1);
9619     } catch (std::out_of_range& e) {
9620       {
9621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9622       };
9623     } catch (std::exception& e) {
9624       {
9625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9626       };
9627     } catch (Dali::DaliException e) {
9628       {
9629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9630       };
9631     } catch (...) {
9632       {
9633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9634       };
9635     }
9636   }
9637
9638   jresult = (void *)result;
9639   return jresult;
9640 }
9641
9642
9643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9644   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9645   float arg2 ;
9646
9647   arg1 = (Dali::Degree *)jarg1;
9648   arg2 = (float)jarg2;
9649   if (arg1) (arg1)->degree = arg2;
9650 }
9651
9652
9653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9654   float jresult ;
9655   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9656   float result;
9657
9658   arg1 = (Dali::Degree *)jarg1;
9659   result = (float) ((arg1)->degree);
9660   jresult = result;
9661   return jresult;
9662 }
9663
9664
9665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9666   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9667
9668   arg1 = (Dali::Degree *)jarg1;
9669   {
9670     try {
9671       delete arg1;
9672     } catch (std::out_of_range& e) {
9673       {
9674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9675       };
9676     } catch (std::exception& e) {
9677       {
9678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9679       };
9680     } catch (Dali::DaliException e) {
9681       {
9682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9683       };
9684     } catch (...) {
9685       {
9686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9687       };
9688     }
9689   }
9690
9691 }
9692
9693
9694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9695   void * jresult ;
9696   Dali::Radian *result = 0 ;
9697
9698   result = (Dali::Radian *)&Dali::ANGLE_360;
9699   jresult = (void *)result;
9700   return jresult;
9701 }
9702
9703
9704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9705   void * jresult ;
9706   Dali::Radian *result = 0 ;
9707
9708   result = (Dali::Radian *)&Dali::ANGLE_315;
9709   jresult = (void *)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9715   void * jresult ;
9716   Dali::Radian *result = 0 ;
9717
9718   result = (Dali::Radian *)&Dali::ANGLE_270;
9719   jresult = (void *)result;
9720   return jresult;
9721 }
9722
9723
9724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9725   void * jresult ;
9726   Dali::Radian *result = 0 ;
9727
9728   result = (Dali::Radian *)&Dali::ANGLE_225;
9729   jresult = (void *)result;
9730   return jresult;
9731 }
9732
9733
9734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9735   void * jresult ;
9736   Dali::Radian *result = 0 ;
9737
9738   result = (Dali::Radian *)&Dali::ANGLE_180;
9739   jresult = (void *)result;
9740   return jresult;
9741 }
9742
9743
9744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9745   void * jresult ;
9746   Dali::Radian *result = 0 ;
9747
9748   result = (Dali::Radian *)&Dali::ANGLE_135;
9749   jresult = (void *)result;
9750   return jresult;
9751 }
9752
9753
9754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9755   void * jresult ;
9756   Dali::Radian *result = 0 ;
9757
9758   result = (Dali::Radian *)&Dali::ANGLE_120;
9759   jresult = (void *)result;
9760   return jresult;
9761 }
9762
9763
9764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9765   void * jresult ;
9766   Dali::Radian *result = 0 ;
9767
9768   result = (Dali::Radian *)&Dali::ANGLE_90;
9769   jresult = (void *)result;
9770   return jresult;
9771 }
9772
9773
9774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9775   void * jresult ;
9776   Dali::Radian *result = 0 ;
9777
9778   result = (Dali::Radian *)&Dali::ANGLE_60;
9779   jresult = (void *)result;
9780   return jresult;
9781 }
9782
9783
9784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9785   void * jresult ;
9786   Dali::Radian *result = 0 ;
9787
9788   result = (Dali::Radian *)&Dali::ANGLE_45;
9789   jresult = (void *)result;
9790   return jresult;
9791 }
9792
9793
9794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9795   void * jresult ;
9796   Dali::Radian *result = 0 ;
9797
9798   result = (Dali::Radian *)&Dali::ANGLE_30;
9799   jresult = (void *)result;
9800   return jresult;
9801 }
9802
9803
9804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9805   void * jresult ;
9806   Dali::Radian *result = 0 ;
9807
9808   result = (Dali::Radian *)&Dali::ANGLE_0;
9809   jresult = (void *)result;
9810   return jresult;
9811 }
9812
9813
9814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9815   unsigned int jresult ;
9816   Dali::Degree *arg1 = 0 ;
9817   Dali::Degree *arg2 = 0 ;
9818   bool result;
9819
9820   arg1 = (Dali::Degree *)jarg1;
9821   if (!arg1) {
9822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9823     return 0;
9824   }
9825   arg2 = (Dali::Degree *)jarg2;
9826   if (!arg2) {
9827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9828     return 0;
9829   }
9830   {
9831     try {
9832       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9833     } catch (std::out_of_range& e) {
9834       {
9835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9836       };
9837     } catch (std::exception& e) {
9838       {
9839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9840       };
9841     } catch (Dali::DaliException e) {
9842       {
9843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9844       };
9845     } catch (...) {
9846       {
9847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9848       };
9849     }
9850   }
9851
9852   jresult = result;
9853   return jresult;
9854 }
9855
9856
9857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9858   unsigned int jresult ;
9859   Dali::Degree *arg1 = 0 ;
9860   Dali::Degree *arg2 = 0 ;
9861   bool result;
9862
9863   arg1 = (Dali::Degree *)jarg1;
9864   if (!arg1) {
9865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9866     return 0;
9867   }
9868   arg2 = (Dali::Degree *)jarg2;
9869   if (!arg2) {
9870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9871     return 0;
9872   }
9873   {
9874     try {
9875       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9876     } catch (std::out_of_range& e) {
9877       {
9878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9879       };
9880     } catch (std::exception& e) {
9881       {
9882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9883       };
9884     } catch (Dali::DaliException e) {
9885       {
9886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9887       };
9888     } catch (...) {
9889       {
9890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9891       };
9892     }
9893   }
9894
9895   jresult = result;
9896   return jresult;
9897 }
9898
9899
9900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9901   void * jresult ;
9902   Dali::Degree arg1 ;
9903   float arg2 ;
9904   float arg3 ;
9905   Dali::Degree *argp1 ;
9906   Dali::Degree result;
9907
9908   argp1 = (Dali::Degree *)jarg1;
9909   if (!argp1) {
9910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9911     return 0;
9912   }
9913   arg1 = *argp1;
9914   arg2 = (float)jarg2;
9915   arg3 = (float)jarg3;
9916   {
9917     try {
9918       result = Dali::Clamp(arg1,arg2,arg3);
9919     } catch (std::out_of_range& e) {
9920       {
9921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9922       };
9923     } catch (std::exception& e) {
9924       {
9925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9926       };
9927     } catch (Dali::DaliException e) {
9928       {
9929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9930       };
9931     } catch (...) {
9932       {
9933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9934       };
9935     }
9936   }
9937
9938   jresult = new Dali::Degree((const Dali::Degree &)result);
9939   return jresult;
9940 }
9941
9942
9943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9944   void * jresult ;
9945   Dali::Radian *result = 0 ;
9946
9947   {
9948     try {
9949       result = (Dali::Radian *)new Dali::Radian();
9950     } catch (std::out_of_range& e) {
9951       {
9952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9953       };
9954     } catch (std::exception& e) {
9955       {
9956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9957       };
9958     } catch (Dali::DaliException e) {
9959       {
9960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9961       };
9962     } catch (...) {
9963       {
9964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9965       };
9966     }
9967   }
9968
9969   jresult = (void *)result;
9970   return jresult;
9971 }
9972
9973
9974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9975   void * jresult ;
9976   float arg1 ;
9977   Dali::Radian *result = 0 ;
9978
9979   arg1 = (float)jarg1;
9980   {
9981     try {
9982       result = (Dali::Radian *)new Dali::Radian(arg1);
9983     } catch (std::out_of_range& e) {
9984       {
9985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9986       };
9987     } catch (std::exception& e) {
9988       {
9989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9990       };
9991     } catch (Dali::DaliException e) {
9992       {
9993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9994       };
9995     } catch (...) {
9996       {
9997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9998       };
9999     }
10000   }
10001
10002   jresult = (void *)result;
10003   return jresult;
10004 }
10005
10006
10007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10008   void * jresult ;
10009   Dali::Degree arg1 ;
10010   Dali::Degree *argp1 ;
10011   Dali::Radian *result = 0 ;
10012
10013   argp1 = (Dali::Degree *)jarg1;
10014   if (!argp1) {
10015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10016     return 0;
10017   }
10018   arg1 = *argp1;
10019   {
10020     try {
10021       result = (Dali::Radian *)new Dali::Radian(arg1);
10022     } catch (std::out_of_range& e) {
10023       {
10024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10025       };
10026     } catch (std::exception& e) {
10027       {
10028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10029       };
10030     } catch (Dali::DaliException e) {
10031       {
10032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10033       };
10034     } catch (...) {
10035       {
10036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10037       };
10038     }
10039   }
10040
10041   jresult = (void *)result;
10042   return jresult;
10043 }
10044
10045
10046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10047   void * jresult ;
10048   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10049   float arg2 ;
10050   Dali::Radian *result = 0 ;
10051
10052   arg1 = (Dali::Radian *)jarg1;
10053   arg2 = (float)jarg2;
10054   {
10055     try {
10056       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10057     } catch (std::out_of_range& e) {
10058       {
10059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10060       };
10061     } catch (std::exception& e) {
10062       {
10063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10064       };
10065     } catch (Dali::DaliException e) {
10066       {
10067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10068       };
10069     } catch (...) {
10070       {
10071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10072       };
10073     }
10074   }
10075
10076   jresult = (void *)result;
10077   return jresult;
10078 }
10079
10080
10081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10082   void * jresult ;
10083   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10084   Dali::Degree arg2 ;
10085   Dali::Degree *argp2 ;
10086   Dali::Radian *result = 0 ;
10087
10088   arg1 = (Dali::Radian *)jarg1;
10089   argp2 = (Dali::Degree *)jarg2;
10090   if (!argp2) {
10091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10092     return 0;
10093   }
10094   arg2 = *argp2;
10095   {
10096     try {
10097       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10098     } catch (std::out_of_range& e) {
10099       {
10100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10101       };
10102     } catch (std::exception& e) {
10103       {
10104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10105       };
10106     } catch (Dali::DaliException e) {
10107       {
10108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10109       };
10110     } catch (...) {
10111       {
10112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10113       };
10114     }
10115   }
10116
10117   jresult = (void *)result;
10118   return jresult;
10119 }
10120
10121
10122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10123   float jresult ;
10124   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10125   float result;
10126
10127   arg1 = (Dali::Radian *)jarg1;
10128   {
10129     try {
10130       result = (float)((Dali::Radian const *)arg1)->operator float();
10131     } catch (std::out_of_range& e) {
10132       {
10133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10134       };
10135     } catch (std::exception& e) {
10136       {
10137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10138       };
10139     } catch (Dali::DaliException e) {
10140       {
10141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10142       };
10143     } catch (...) {
10144       {
10145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10146       };
10147     }
10148   }
10149
10150   jresult = result;
10151   return jresult;
10152 }
10153
10154
10155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10156   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10157   float arg2 ;
10158
10159   arg1 = (Dali::Radian *)jarg1;
10160   arg2 = (float)jarg2;
10161   if (arg1) (arg1)->radian = arg2;
10162 }
10163
10164
10165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10166   float jresult ;
10167   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10168   float result;
10169
10170   arg1 = (Dali::Radian *)jarg1;
10171   result = (float) ((arg1)->radian);
10172   jresult = result;
10173   return jresult;
10174 }
10175
10176
10177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10178   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10179
10180   arg1 = (Dali::Radian *)jarg1;
10181   {
10182     try {
10183       delete arg1;
10184     } catch (std::out_of_range& e) {
10185       {
10186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10187       };
10188     } catch (std::exception& e) {
10189       {
10190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10191       };
10192     } catch (Dali::DaliException e) {
10193       {
10194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10195       };
10196     } catch (...) {
10197       {
10198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10199       };
10200     }
10201   }
10202
10203 }
10204
10205
10206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10207   unsigned int jresult ;
10208   Dali::Radian arg1 ;
10209   Dali::Radian arg2 ;
10210   Dali::Radian *argp1 ;
10211   Dali::Radian *argp2 ;
10212   bool result;
10213
10214   argp1 = (Dali::Radian *)jarg1;
10215   if (!argp1) {
10216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10217     return 0;
10218   }
10219   arg1 = *argp1;
10220   argp2 = (Dali::Radian *)jarg2;
10221   if (!argp2) {
10222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10223     return 0;
10224   }
10225   arg2 = *argp2;
10226   {
10227     try {
10228       result = (bool)Dali::operator ==(arg1,arg2);
10229     } catch (std::out_of_range& e) {
10230       {
10231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10232       };
10233     } catch (std::exception& e) {
10234       {
10235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10236       };
10237     } catch (Dali::DaliException e) {
10238       {
10239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10240       };
10241     } catch (...) {
10242       {
10243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10244       };
10245     }
10246   }
10247
10248   jresult = result;
10249   return jresult;
10250 }
10251
10252
10253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10254   unsigned int jresult ;
10255   Dali::Radian arg1 ;
10256   Dali::Radian arg2 ;
10257   Dali::Radian *argp1 ;
10258   Dali::Radian *argp2 ;
10259   bool result;
10260
10261   argp1 = (Dali::Radian *)jarg1;
10262   if (!argp1) {
10263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10264     return 0;
10265   }
10266   arg1 = *argp1;
10267   argp2 = (Dali::Radian *)jarg2;
10268   if (!argp2) {
10269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10270     return 0;
10271   }
10272   arg2 = *argp2;
10273   {
10274     try {
10275       result = (bool)Dali::operator !=(arg1,arg2);
10276     } catch (std::out_of_range& e) {
10277       {
10278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10279       };
10280     } catch (std::exception& e) {
10281       {
10282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10283       };
10284     } catch (Dali::DaliException e) {
10285       {
10286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10287       };
10288     } catch (...) {
10289       {
10290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10291       };
10292     }
10293   }
10294
10295   jresult = result;
10296   return jresult;
10297 }
10298
10299
10300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10301   unsigned int jresult ;
10302   Dali::Radian arg1 ;
10303   Dali::Degree arg2 ;
10304   Dali::Radian *argp1 ;
10305   Dali::Degree *argp2 ;
10306   bool result;
10307
10308   argp1 = (Dali::Radian *)jarg1;
10309   if (!argp1) {
10310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10311     return 0;
10312   }
10313   arg1 = *argp1;
10314   argp2 = (Dali::Degree *)jarg2;
10315   if (!argp2) {
10316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10317     return 0;
10318   }
10319   arg2 = *argp2;
10320   {
10321     try {
10322       result = (bool)Dali::operator ==(arg1,arg2);
10323     } catch (std::out_of_range& e) {
10324       {
10325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10326       };
10327     } catch (std::exception& e) {
10328       {
10329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10330       };
10331     } catch (Dali::DaliException e) {
10332       {
10333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10334       };
10335     } catch (...) {
10336       {
10337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10338       };
10339     }
10340   }
10341
10342   jresult = result;
10343   return jresult;
10344 }
10345
10346
10347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10348   unsigned int jresult ;
10349   Dali::Radian arg1 ;
10350   Dali::Degree arg2 ;
10351   Dali::Radian *argp1 ;
10352   Dali::Degree *argp2 ;
10353   bool result;
10354
10355   argp1 = (Dali::Radian *)jarg1;
10356   if (!argp1) {
10357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10358     return 0;
10359   }
10360   arg1 = *argp1;
10361   argp2 = (Dali::Degree *)jarg2;
10362   if (!argp2) {
10363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10364     return 0;
10365   }
10366   arg2 = *argp2;
10367   {
10368     try {
10369       result = (bool)Dali::operator !=(arg1,arg2);
10370     } catch (std::out_of_range& e) {
10371       {
10372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10373       };
10374     } catch (std::exception& e) {
10375       {
10376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10377       };
10378     } catch (Dali::DaliException e) {
10379       {
10380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10381       };
10382     } catch (...) {
10383       {
10384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10385       };
10386     }
10387   }
10388
10389   jresult = result;
10390   return jresult;
10391 }
10392
10393
10394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10395   unsigned int jresult ;
10396   Dali::Degree arg1 ;
10397   Dali::Radian arg2 ;
10398   Dali::Degree *argp1 ;
10399   Dali::Radian *argp2 ;
10400   bool result;
10401
10402   argp1 = (Dali::Degree *)jarg1;
10403   if (!argp1) {
10404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10405     return 0;
10406   }
10407   arg1 = *argp1;
10408   argp2 = (Dali::Radian *)jarg2;
10409   if (!argp2) {
10410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10411     return 0;
10412   }
10413   arg2 = *argp2;
10414   {
10415     try {
10416       result = (bool)Dali::operator ==(arg1,arg2);
10417     } catch (std::out_of_range& e) {
10418       {
10419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10420       };
10421     } catch (std::exception& e) {
10422       {
10423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10424       };
10425     } catch (Dali::DaliException e) {
10426       {
10427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10428       };
10429     } catch (...) {
10430       {
10431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10432       };
10433     }
10434   }
10435
10436   jresult = result;
10437   return jresult;
10438 }
10439
10440
10441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10442   unsigned int jresult ;
10443   Dali::Degree arg1 ;
10444   Dali::Radian arg2 ;
10445   Dali::Degree *argp1 ;
10446   Dali::Radian *argp2 ;
10447   bool result;
10448
10449   argp1 = (Dali::Degree *)jarg1;
10450   if (!argp1) {
10451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10452     return 0;
10453   }
10454   arg1 = *argp1;
10455   argp2 = (Dali::Radian *)jarg2;
10456   if (!argp2) {
10457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10458     return 0;
10459   }
10460   arg2 = *argp2;
10461   {
10462     try {
10463       result = (bool)Dali::operator !=(arg1,arg2);
10464     } catch (std::out_of_range& e) {
10465       {
10466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10467       };
10468     } catch (std::exception& e) {
10469       {
10470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10471       };
10472     } catch (Dali::DaliException e) {
10473       {
10474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10475       };
10476     } catch (...) {
10477       {
10478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10479       };
10480     }
10481   }
10482
10483   jresult = result;
10484   return jresult;
10485 }
10486
10487
10488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10489   unsigned int jresult ;
10490   Dali::Radian arg1 ;
10491   Dali::Radian arg2 ;
10492   Dali::Radian *argp1 ;
10493   Dali::Radian *argp2 ;
10494   bool result;
10495
10496   argp1 = (Dali::Radian *)jarg1;
10497   if (!argp1) {
10498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10499     return 0;
10500   }
10501   arg1 = *argp1;
10502   argp2 = (Dali::Radian *)jarg2;
10503   if (!argp2) {
10504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10505     return 0;
10506   }
10507   arg2 = *argp2;
10508   {
10509     try {
10510       result = (bool)Dali::operator >(arg1,arg2);
10511     } catch (std::out_of_range& e) {
10512       {
10513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10514       };
10515     } catch (std::exception& e) {
10516       {
10517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10518       };
10519     } catch (Dali::DaliException e) {
10520       {
10521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10522       };
10523     } catch (...) {
10524       {
10525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10526       };
10527     }
10528   }
10529
10530   jresult = result;
10531   return jresult;
10532 }
10533
10534
10535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10536   unsigned int jresult ;
10537   Dali::Radian arg1 ;
10538   Dali::Degree arg2 ;
10539   Dali::Radian *argp1 ;
10540   Dali::Degree *argp2 ;
10541   bool result;
10542
10543   argp1 = (Dali::Radian *)jarg1;
10544   if (!argp1) {
10545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10546     return 0;
10547   }
10548   arg1 = *argp1;
10549   argp2 = (Dali::Degree *)jarg2;
10550   if (!argp2) {
10551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10552     return 0;
10553   }
10554   arg2 = *argp2;
10555   {
10556     try {
10557       result = (bool)Dali::operator >(arg1,arg2);
10558     } catch (std::out_of_range& e) {
10559       {
10560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10561       };
10562     } catch (std::exception& e) {
10563       {
10564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10565       };
10566     } catch (Dali::DaliException e) {
10567       {
10568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10569       };
10570     } catch (...) {
10571       {
10572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10573       };
10574     }
10575   }
10576
10577   jresult = result;
10578   return jresult;
10579 }
10580
10581
10582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10583   unsigned int jresult ;
10584   Dali::Degree arg1 ;
10585   Dali::Radian arg2 ;
10586   Dali::Degree *argp1 ;
10587   Dali::Radian *argp2 ;
10588   bool result;
10589
10590   argp1 = (Dali::Degree *)jarg1;
10591   if (!argp1) {
10592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10593     return 0;
10594   }
10595   arg1 = *argp1;
10596   argp2 = (Dali::Radian *)jarg2;
10597   if (!argp2) {
10598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10599     return 0;
10600   }
10601   arg2 = *argp2;
10602   {
10603     try {
10604       result = (bool)Dali::operator >(arg1,arg2);
10605     } catch (std::out_of_range& e) {
10606       {
10607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10608       };
10609     } catch (std::exception& e) {
10610       {
10611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10612       };
10613     } catch (Dali::DaliException e) {
10614       {
10615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10616       };
10617     } catch (...) {
10618       {
10619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10620       };
10621     }
10622   }
10623
10624   jresult = result;
10625   return jresult;
10626 }
10627
10628
10629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10630   unsigned int jresult ;
10631   Dali::Radian arg1 ;
10632   Dali::Radian arg2 ;
10633   Dali::Radian *argp1 ;
10634   Dali::Radian *argp2 ;
10635   bool result;
10636
10637   argp1 = (Dali::Radian *)jarg1;
10638   if (!argp1) {
10639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10640     return 0;
10641   }
10642   arg1 = *argp1;
10643   argp2 = (Dali::Radian *)jarg2;
10644   if (!argp2) {
10645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10646     return 0;
10647   }
10648   arg2 = *argp2;
10649   {
10650     try {
10651       result = (bool)Dali::operator <(arg1,arg2);
10652     } catch (std::out_of_range& e) {
10653       {
10654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10655       };
10656     } catch (std::exception& e) {
10657       {
10658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10659       };
10660     } catch (Dali::DaliException e) {
10661       {
10662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10663       };
10664     } catch (...) {
10665       {
10666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10667       };
10668     }
10669   }
10670
10671   jresult = result;
10672   return jresult;
10673 }
10674
10675
10676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10677   unsigned int jresult ;
10678   Dali::Radian arg1 ;
10679   Dali::Degree arg2 ;
10680   Dali::Radian *argp1 ;
10681   Dali::Degree *argp2 ;
10682   bool result;
10683
10684   argp1 = (Dali::Radian *)jarg1;
10685   if (!argp1) {
10686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10687     return 0;
10688   }
10689   arg1 = *argp1;
10690   argp2 = (Dali::Degree *)jarg2;
10691   if (!argp2) {
10692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10693     return 0;
10694   }
10695   arg2 = *argp2;
10696   {
10697     try {
10698       result = (bool)Dali::operator <(arg1,arg2);
10699     } catch (std::out_of_range& e) {
10700       {
10701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10702       };
10703     } catch (std::exception& e) {
10704       {
10705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10706       };
10707     } catch (Dali::DaliException e) {
10708       {
10709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10710       };
10711     } catch (...) {
10712       {
10713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10714       };
10715     }
10716   }
10717
10718   jresult = result;
10719   return jresult;
10720 }
10721
10722
10723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10724   unsigned int jresult ;
10725   Dali::Degree arg1 ;
10726   Dali::Radian arg2 ;
10727   Dali::Degree *argp1 ;
10728   Dali::Radian *argp2 ;
10729   bool result;
10730
10731   argp1 = (Dali::Degree *)jarg1;
10732   if (!argp1) {
10733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10734     return 0;
10735   }
10736   arg1 = *argp1;
10737   argp2 = (Dali::Radian *)jarg2;
10738   if (!argp2) {
10739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10740     return 0;
10741   }
10742   arg2 = *argp2;
10743   {
10744     try {
10745       result = (bool)Dali::operator <(arg1,arg2);
10746     } catch (std::out_of_range& e) {
10747       {
10748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10749       };
10750     } catch (std::exception& e) {
10751       {
10752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10753       };
10754     } catch (Dali::DaliException e) {
10755       {
10756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10757       };
10758     } catch (...) {
10759       {
10760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10761       };
10762     }
10763   }
10764
10765   jresult = result;
10766   return jresult;
10767 }
10768
10769
10770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10771   void * jresult ;
10772   Dali::Radian arg1 ;
10773   float arg2 ;
10774   Dali::Radian *argp1 ;
10775   Dali::Radian result;
10776
10777   argp1 = (Dali::Radian *)jarg1;
10778   if (!argp1) {
10779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10780     return 0;
10781   }
10782   arg1 = *argp1;
10783   arg2 = (float)jarg2;
10784   {
10785     try {
10786       result = Dali::operator *(arg1,arg2);
10787     } catch (std::out_of_range& e) {
10788       {
10789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10790       };
10791     } catch (std::exception& e) {
10792       {
10793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10794       };
10795     } catch (Dali::DaliException e) {
10796       {
10797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10798       };
10799     } catch (...) {
10800       {
10801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10802       };
10803     }
10804   }
10805
10806   jresult = new Dali::Radian((const Dali::Radian &)result);
10807   return jresult;
10808 }
10809
10810
10811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10812   void * jresult ;
10813   Dali::Radian arg1 ;
10814   Dali::Radian *argp1 ;
10815   Dali::Radian result;
10816
10817   argp1 = (Dali::Radian *)jarg1;
10818   if (!argp1) {
10819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10820     return 0;
10821   }
10822   arg1 = *argp1;
10823   {
10824     try {
10825       result = Dali::operator -(arg1);
10826     } catch (std::out_of_range& e) {
10827       {
10828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10829       };
10830     } catch (std::exception& e) {
10831       {
10832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10833       };
10834     } catch (Dali::DaliException e) {
10835       {
10836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10837       };
10838     } catch (...) {
10839       {
10840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10841       };
10842     }
10843   }
10844
10845   jresult = new Dali::Radian((const Dali::Radian &)result);
10846   return jresult;
10847 }
10848
10849
10850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10851   void * jresult ;
10852   Dali::Radian arg1 ;
10853   float arg2 ;
10854   float arg3 ;
10855   Dali::Radian *argp1 ;
10856   Dali::Radian result;
10857
10858   argp1 = (Dali::Radian *)jarg1;
10859   if (!argp1) {
10860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10861     return 0;
10862   }
10863   arg1 = *argp1;
10864   arg2 = (float)jarg2;
10865   arg3 = (float)jarg3;
10866   {
10867     try {
10868       result = Dali::Clamp(arg1,arg2,arg3);
10869     } catch (std::out_of_range& e) {
10870       {
10871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10872       };
10873     } catch (std::exception& e) {
10874       {
10875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10876       };
10877     } catch (Dali::DaliException e) {
10878       {
10879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10880       };
10881     } catch (...) {
10882       {
10883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10884       };
10885     }
10886   }
10887
10888   jresult = new Dali::Radian((const Dali::Radian &)result);
10889   return jresult;
10890 }
10891
10892
10893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10894   void * jresult ;
10895   Dali::Quaternion *result = 0 ;
10896
10897   {
10898     try {
10899       result = (Dali::Quaternion *)new Dali::Quaternion();
10900     } catch (std::out_of_range& e) {
10901       {
10902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10903       };
10904     } catch (std::exception& e) {
10905       {
10906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10907       };
10908     } catch (Dali::DaliException e) {
10909       {
10910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10911       };
10912     } catch (...) {
10913       {
10914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10915       };
10916     }
10917   }
10918
10919   jresult = (void *)result;
10920   return jresult;
10921 }
10922
10923
10924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10925   void * jresult ;
10926   Dali::Radian arg1 ;
10927   Dali::Vector3 *arg2 = 0 ;
10928   Dali::Radian *argp1 ;
10929   Dali::Quaternion *result = 0 ;
10930
10931   argp1 = (Dali::Radian *)jarg1;
10932   if (!argp1) {
10933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10934     return 0;
10935   }
10936   arg1 = *argp1;
10937   arg2 = (Dali::Vector3 *)jarg2;
10938   if (!arg2) {
10939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10940     return 0;
10941   }
10942   {
10943     try {
10944       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10945     } catch (std::out_of_range& e) {
10946       {
10947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10948       };
10949     } catch (std::exception& e) {
10950       {
10951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10952       };
10953     } catch (Dali::DaliException e) {
10954       {
10955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10956       };
10957     } catch (...) {
10958       {
10959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10960       };
10961     }
10962   }
10963
10964   jresult = (void *)result;
10965   return jresult;
10966 }
10967
10968
10969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10970   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10971
10972   arg1 = (Dali::Quaternion *)jarg1;
10973   {
10974     try {
10975       delete arg1;
10976     } catch (std::out_of_range& e) {
10977       {
10978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10979       };
10980     } catch (std::exception& e) {
10981       {
10982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10983       };
10984     } catch (Dali::DaliException e) {
10985       {
10986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10987       };
10988     } catch (...) {
10989       {
10990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10991       };
10992     }
10993   }
10994
10995 }
10996
10997
10998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10999   void * jresult ;
11000   Dali::Quaternion *result = 0 ;
11001
11002   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11003   jresult = (void *)result;
11004   return jresult;
11005 }
11006
11007
11008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11009   unsigned int jresult ;
11010   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11011   bool result;
11012
11013   arg1 = (Dali::Quaternion *)jarg1;
11014   {
11015     try {
11016       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11017     } catch (std::out_of_range& e) {
11018       {
11019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11020       };
11021     } catch (std::exception& e) {
11022       {
11023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11024       };
11025     } catch (Dali::DaliException e) {
11026       {
11027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11028       };
11029     } catch (...) {
11030       {
11031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11032       };
11033     }
11034   }
11035
11036   jresult = result;
11037   return jresult;
11038 }
11039
11040
11041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11042   unsigned int jresult ;
11043   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11044   Dali::Vector3 *arg2 = 0 ;
11045   Dali::Radian *arg3 = 0 ;
11046   bool result;
11047
11048   arg1 = (Dali::Quaternion *)jarg1;
11049   arg2 = (Dali::Vector3 *)jarg2;
11050   if (!arg2) {
11051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11052     return 0;
11053   }
11054   arg3 = (Dali::Radian *)jarg3;
11055   if (!arg3) {
11056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11057     return 0;
11058   }
11059   {
11060     try {
11061       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11062     } catch (std::out_of_range& e) {
11063       {
11064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11065       };
11066     } catch (std::exception& e) {
11067       {
11068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11069       };
11070     } catch (Dali::DaliException e) {
11071       {
11072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11073       };
11074     } catch (...) {
11075       {
11076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11077       };
11078     }
11079   }
11080
11081   jresult = result;
11082   return jresult;
11083 }
11084
11085
11086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11087   void * jresult ;
11088   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11089   Dali::Quaternion *arg2 = 0 ;
11090   Dali::Quaternion result;
11091
11092   arg1 = (Dali::Quaternion *)jarg1;
11093   arg2 = (Dali::Quaternion *)jarg2;
11094   if (!arg2) {
11095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11096     return 0;
11097   }
11098   {
11099     try {
11100       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11101     } catch (std::out_of_range& e) {
11102       {
11103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11104       };
11105     } catch (std::exception& e) {
11106       {
11107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11108       };
11109     } catch (Dali::DaliException e) {
11110       {
11111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11112       };
11113     } catch (...) {
11114       {
11115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11116       };
11117     }
11118   }
11119
11120   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11121   return jresult;
11122 }
11123
11124
11125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11126   void * jresult ;
11127   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11128   Dali::Quaternion *arg2 = 0 ;
11129   Dali::Quaternion result;
11130
11131   arg1 = (Dali::Quaternion *)jarg1;
11132   arg2 = (Dali::Quaternion *)jarg2;
11133   if (!arg2) {
11134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11135     return 0;
11136   }
11137   {
11138     try {
11139       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11140     } catch (std::out_of_range& e) {
11141       {
11142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11143       };
11144     } catch (std::exception& e) {
11145       {
11146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11147       };
11148     } catch (Dali::DaliException e) {
11149       {
11150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11151       };
11152     } catch (...) {
11153       {
11154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11155       };
11156     }
11157   }
11158
11159   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11160   return jresult;
11161 }
11162
11163
11164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11165   void * jresult ;
11166   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11167   Dali::Quaternion *arg2 = 0 ;
11168   Dali::Quaternion result;
11169
11170   arg1 = (Dali::Quaternion *)jarg1;
11171   arg2 = (Dali::Quaternion *)jarg2;
11172   if (!arg2) {
11173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11174     return 0;
11175   }
11176   {
11177     try {
11178       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11179     } catch (std::out_of_range& e) {
11180       {
11181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11182       };
11183     } catch (std::exception& e) {
11184       {
11185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11186       };
11187     } catch (Dali::DaliException e) {
11188       {
11189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11190       };
11191     } catch (...) {
11192       {
11193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11194       };
11195     }
11196   }
11197
11198   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11199   return jresult;
11200 }
11201
11202
11203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11204   void * jresult ;
11205   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11206   Dali::Vector3 *arg2 = 0 ;
11207   Dali::Vector3 result;
11208
11209   arg1 = (Dali::Quaternion *)jarg1;
11210   arg2 = (Dali::Vector3 *)jarg2;
11211   if (!arg2) {
11212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11213     return 0;
11214   }
11215   {
11216     try {
11217       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11218     } catch (std::out_of_range& e) {
11219       {
11220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11221       };
11222     } catch (std::exception& e) {
11223       {
11224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11225       };
11226     } catch (Dali::DaliException e) {
11227       {
11228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11229       };
11230     } catch (...) {
11231       {
11232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11233       };
11234     }
11235   }
11236
11237   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11238   return jresult;
11239 }
11240
11241
11242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11243   void * jresult ;
11244   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11245   Dali::Quaternion *arg2 = 0 ;
11246   Dali::Quaternion result;
11247
11248   arg1 = (Dali::Quaternion *)jarg1;
11249   arg2 = (Dali::Quaternion *)jarg2;
11250   if (!arg2) {
11251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11252     return 0;
11253   }
11254   {
11255     try {
11256       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11257     } catch (std::out_of_range& e) {
11258       {
11259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11260       };
11261     } catch (std::exception& e) {
11262       {
11263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11264       };
11265     } catch (Dali::DaliException e) {
11266       {
11267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11268       };
11269     } catch (...) {
11270       {
11271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11272       };
11273     }
11274   }
11275
11276   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11277   return jresult;
11278 }
11279
11280
11281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11282   void * jresult ;
11283   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11284   float arg2 ;
11285   Dali::Quaternion result;
11286
11287   arg1 = (Dali::Quaternion *)jarg1;
11288   arg2 = (float)jarg2;
11289   {
11290     try {
11291       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11292     } catch (std::out_of_range& e) {
11293       {
11294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11295       };
11296     } catch (std::exception& e) {
11297       {
11298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11299       };
11300     } catch (Dali::DaliException e) {
11301       {
11302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11303       };
11304     } catch (...) {
11305       {
11306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11307       };
11308     }
11309   }
11310
11311   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11312   return jresult;
11313 }
11314
11315
11316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11317   void * jresult ;
11318   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11319   float arg2 ;
11320   Dali::Quaternion result;
11321
11322   arg1 = (Dali::Quaternion *)jarg1;
11323   arg2 = (float)jarg2;
11324   {
11325     try {
11326       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11327     } catch (std::out_of_range& e) {
11328       {
11329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11330       };
11331     } catch (std::exception& e) {
11332       {
11333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11334       };
11335     } catch (Dali::DaliException e) {
11336       {
11337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11338       };
11339     } catch (...) {
11340       {
11341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11342       };
11343     }
11344   }
11345
11346   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11347   return jresult;
11348 }
11349
11350
11351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11352   void * jresult ;
11353   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11354   Dali::Quaternion result;
11355
11356   arg1 = (Dali::Quaternion *)jarg1;
11357   {
11358     try {
11359       result = ((Dali::Quaternion const *)arg1)->operator -();
11360     } catch (std::out_of_range& e) {
11361       {
11362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11363       };
11364     } catch (std::exception& e) {
11365       {
11366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11367       };
11368     } catch (Dali::DaliException e) {
11369       {
11370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11371       };
11372     } catch (...) {
11373       {
11374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11375       };
11376     }
11377   }
11378
11379   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11380   return jresult;
11381 }
11382
11383
11384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11385   void * jresult ;
11386   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11387   Dali::Quaternion *arg2 = 0 ;
11388   Dali::Quaternion *result = 0 ;
11389
11390   arg1 = (Dali::Quaternion *)jarg1;
11391   arg2 = (Dali::Quaternion *)jarg2;
11392   if (!arg2) {
11393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11394     return 0;
11395   }
11396   {
11397     try {
11398       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11399     } catch (std::out_of_range& e) {
11400       {
11401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11402       };
11403     } catch (std::exception& e) {
11404       {
11405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11406       };
11407     } catch (Dali::DaliException e) {
11408       {
11409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11410       };
11411     } catch (...) {
11412       {
11413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11414       };
11415     }
11416   }
11417
11418   jresult = (void *)result;
11419   return jresult;
11420 }
11421
11422
11423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11424   void * jresult ;
11425   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11426   Dali::Quaternion *arg2 = 0 ;
11427   Dali::Quaternion *result = 0 ;
11428
11429   arg1 = (Dali::Quaternion *)jarg1;
11430   arg2 = (Dali::Quaternion *)jarg2;
11431   if (!arg2) {
11432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11433     return 0;
11434   }
11435   {
11436     try {
11437       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11438     } catch (std::out_of_range& e) {
11439       {
11440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11441       };
11442     } catch (std::exception& e) {
11443       {
11444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11445       };
11446     } catch (Dali::DaliException e) {
11447       {
11448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11449       };
11450     } catch (...) {
11451       {
11452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11453       };
11454     }
11455   }
11456
11457   jresult = (void *)result;
11458   return jresult;
11459 }
11460
11461
11462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11463   void * jresult ;
11464   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11465   Dali::Quaternion *arg2 = 0 ;
11466   Dali::Quaternion *result = 0 ;
11467
11468   arg1 = (Dali::Quaternion *)jarg1;
11469   arg2 = (Dali::Quaternion *)jarg2;
11470   if (!arg2) {
11471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11472     return 0;
11473   }
11474   {
11475     try {
11476       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11477     } catch (std::out_of_range& e) {
11478       {
11479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11480       };
11481     } catch (std::exception& e) {
11482       {
11483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11484       };
11485     } catch (Dali::DaliException e) {
11486       {
11487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11488       };
11489     } catch (...) {
11490       {
11491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11492       };
11493     }
11494   }
11495
11496   jresult = (void *)result;
11497   return jresult;
11498 }
11499
11500
11501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11502   void * jresult ;
11503   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11504   float arg2 ;
11505   Dali::Quaternion *result = 0 ;
11506
11507   arg1 = (Dali::Quaternion *)jarg1;
11508   arg2 = (float)jarg2;
11509   {
11510     try {
11511       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11512     } catch (std::out_of_range& e) {
11513       {
11514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11515       };
11516     } catch (std::exception& e) {
11517       {
11518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11519       };
11520     } catch (Dali::DaliException e) {
11521       {
11522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11523       };
11524     } catch (...) {
11525       {
11526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11527       };
11528     }
11529   }
11530
11531   jresult = (void *)result;
11532   return jresult;
11533 }
11534
11535
11536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11537   void * jresult ;
11538   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11539   float arg2 ;
11540   Dali::Quaternion *result = 0 ;
11541
11542   arg1 = (Dali::Quaternion *)jarg1;
11543   arg2 = (float)jarg2;
11544   {
11545     try {
11546       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11547     } catch (std::out_of_range& e) {
11548       {
11549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11550       };
11551     } catch (std::exception& e) {
11552       {
11553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11554       };
11555     } catch (Dali::DaliException e) {
11556       {
11557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11558       };
11559     } catch (...) {
11560       {
11561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11562       };
11563     }
11564   }
11565
11566   jresult = (void *)result;
11567   return jresult;
11568 }
11569
11570
11571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11572   unsigned int jresult ;
11573   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11574   Dali::Quaternion *arg2 = 0 ;
11575   bool result;
11576
11577   arg1 = (Dali::Quaternion *)jarg1;
11578   arg2 = (Dali::Quaternion *)jarg2;
11579   if (!arg2) {
11580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11581     return 0;
11582   }
11583   {
11584     try {
11585       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11586     } catch (std::out_of_range& e) {
11587       {
11588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11589       };
11590     } catch (std::exception& e) {
11591       {
11592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11593       };
11594     } catch (Dali::DaliException e) {
11595       {
11596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11597       };
11598     } catch (...) {
11599       {
11600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11601       };
11602     }
11603   }
11604
11605   jresult = result;
11606   return jresult;
11607 }
11608
11609
11610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11611   unsigned int jresult ;
11612   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11613   Dali::Quaternion *arg2 = 0 ;
11614   bool result;
11615
11616   arg1 = (Dali::Quaternion *)jarg1;
11617   arg2 = (Dali::Quaternion *)jarg2;
11618   if (!arg2) {
11619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11620     return 0;
11621   }
11622   {
11623     try {
11624       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11625     } catch (std::out_of_range& e) {
11626       {
11627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11628       };
11629     } catch (std::exception& e) {
11630       {
11631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11632       };
11633     } catch (Dali::DaliException e) {
11634       {
11635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11636       };
11637     } catch (...) {
11638       {
11639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11640       };
11641     }
11642   }
11643
11644   jresult = result;
11645   return jresult;
11646 }
11647
11648
11649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11650   float jresult ;
11651   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11652   float result;
11653
11654   arg1 = (Dali::Quaternion *)jarg1;
11655   {
11656     try {
11657       result = (float)((Dali::Quaternion const *)arg1)->Length();
11658     } catch (std::out_of_range& e) {
11659       {
11660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11661       };
11662     } catch (std::exception& e) {
11663       {
11664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11665       };
11666     } catch (Dali::DaliException e) {
11667       {
11668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11669       };
11670     } catch (...) {
11671       {
11672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11673       };
11674     }
11675   }
11676
11677   jresult = result;
11678   return jresult;
11679 }
11680
11681
11682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11683   float jresult ;
11684   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11685   float result;
11686
11687   arg1 = (Dali::Quaternion *)jarg1;
11688   {
11689     try {
11690       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11691     } catch (std::out_of_range& e) {
11692       {
11693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11694       };
11695     } catch (std::exception& e) {
11696       {
11697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11698       };
11699     } catch (Dali::DaliException e) {
11700       {
11701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11702       };
11703     } catch (...) {
11704       {
11705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11706       };
11707     }
11708   }
11709
11710   jresult = result;
11711   return jresult;
11712 }
11713
11714
11715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11716   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11717
11718   arg1 = (Dali::Quaternion *)jarg1;
11719   {
11720     try {
11721       (arg1)->Normalize();
11722     } catch (std::out_of_range& e) {
11723       {
11724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11725       };
11726     } catch (std::exception& e) {
11727       {
11728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11729       };
11730     } catch (Dali::DaliException e) {
11731       {
11732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11733       };
11734     } catch (...) {
11735       {
11736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11737       };
11738     }
11739   }
11740
11741 }
11742
11743
11744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11745   void * jresult ;
11746   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11747   Dali::Quaternion result;
11748
11749   arg1 = (Dali::Quaternion *)jarg1;
11750   {
11751     try {
11752       result = ((Dali::Quaternion const *)arg1)->Normalized();
11753     } catch (std::out_of_range& e) {
11754       {
11755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11756       };
11757     } catch (std::exception& e) {
11758       {
11759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11760       };
11761     } catch (Dali::DaliException e) {
11762       {
11763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11764       };
11765     } catch (...) {
11766       {
11767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11768       };
11769     }
11770   }
11771
11772   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11773   return jresult;
11774 }
11775
11776
11777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11778   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11779
11780   arg1 = (Dali::Quaternion *)jarg1;
11781   {
11782     try {
11783       (arg1)->Conjugate();
11784     } catch (std::out_of_range& e) {
11785       {
11786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11787       };
11788     } catch (std::exception& e) {
11789       {
11790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11791       };
11792     } catch (Dali::DaliException e) {
11793       {
11794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11795       };
11796     } catch (...) {
11797       {
11798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11799       };
11800     }
11801   }
11802
11803 }
11804
11805
11806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11807   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11808
11809   arg1 = (Dali::Quaternion *)jarg1;
11810   {
11811     try {
11812       (arg1)->Invert();
11813     } catch (std::out_of_range& e) {
11814       {
11815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11816       };
11817     } catch (std::exception& e) {
11818       {
11819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11820       };
11821     } catch (Dali::DaliException e) {
11822       {
11823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11824       };
11825     } catch (...) {
11826       {
11827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11828       };
11829     }
11830   }
11831
11832 }
11833
11834
11835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11836   void * jresult ;
11837   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11838   Dali::Quaternion result;
11839
11840   arg1 = (Dali::Quaternion *)jarg1;
11841   {
11842     try {
11843       result = ((Dali::Quaternion const *)arg1)->Log();
11844     } catch (std::out_of_range& e) {
11845       {
11846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11847       };
11848     } catch (std::exception& e) {
11849       {
11850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11851       };
11852     } catch (Dali::DaliException e) {
11853       {
11854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11855       };
11856     } catch (...) {
11857       {
11858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11859       };
11860     }
11861   }
11862
11863   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11864   return jresult;
11865 }
11866
11867
11868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11869   void * jresult ;
11870   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11871   Dali::Quaternion result;
11872
11873   arg1 = (Dali::Quaternion *)jarg1;
11874   {
11875     try {
11876       result = ((Dali::Quaternion const *)arg1)->Exp();
11877     } catch (std::out_of_range& e) {
11878       {
11879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11880       };
11881     } catch (std::exception& e) {
11882       {
11883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11884       };
11885     } catch (Dali::DaliException e) {
11886       {
11887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11888       };
11889     } catch (...) {
11890       {
11891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11892       };
11893     }
11894   }
11895
11896   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11897   return jresult;
11898 }
11899
11900
11901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11902   float jresult ;
11903   Dali::Quaternion *arg1 = 0 ;
11904   Dali::Quaternion *arg2 = 0 ;
11905   float result;
11906
11907   arg1 = (Dali::Quaternion *)jarg1;
11908   if (!arg1) {
11909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11910     return 0;
11911   }
11912   arg2 = (Dali::Quaternion *)jarg2;
11913   if (!arg2) {
11914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11915     return 0;
11916   }
11917   {
11918     try {
11919       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11920     } catch (std::out_of_range& e) {
11921       {
11922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11923       };
11924     } catch (std::exception& e) {
11925       {
11926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11927       };
11928     } catch (Dali::DaliException e) {
11929       {
11930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11931       };
11932     } catch (...) {
11933       {
11934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11935       };
11936     }
11937   }
11938
11939   jresult = result;
11940   return jresult;
11941 }
11942
11943
11944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11945   void * jresult ;
11946   Dali::Quaternion *arg1 = 0 ;
11947   Dali::Quaternion *arg2 = 0 ;
11948   float arg3 ;
11949   Dali::Quaternion result;
11950
11951   arg1 = (Dali::Quaternion *)jarg1;
11952   if (!arg1) {
11953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11954     return 0;
11955   }
11956   arg2 = (Dali::Quaternion *)jarg2;
11957   if (!arg2) {
11958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11959     return 0;
11960   }
11961   arg3 = (float)jarg3;
11962   {
11963     try {
11964       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11965     } catch (std::out_of_range& e) {
11966       {
11967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11968       };
11969     } catch (std::exception& e) {
11970       {
11971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11972       };
11973     } catch (Dali::DaliException e) {
11974       {
11975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11976       };
11977     } catch (...) {
11978       {
11979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11980       };
11981     }
11982   }
11983
11984   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11985   return jresult;
11986 }
11987
11988
11989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11990   void * jresult ;
11991   Dali::Quaternion *arg1 = 0 ;
11992   Dali::Quaternion *arg2 = 0 ;
11993   float arg3 ;
11994   Dali::Quaternion result;
11995
11996   arg1 = (Dali::Quaternion *)jarg1;
11997   if (!arg1) {
11998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11999     return 0;
12000   }
12001   arg2 = (Dali::Quaternion *)jarg2;
12002   if (!arg2) {
12003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12004     return 0;
12005   }
12006   arg3 = (float)jarg3;
12007   {
12008     try {
12009       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12010     } catch (std::out_of_range& e) {
12011       {
12012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12013       };
12014     } catch (std::exception& e) {
12015       {
12016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12017       };
12018     } catch (Dali::DaliException e) {
12019       {
12020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12021       };
12022     } catch (...) {
12023       {
12024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12025       };
12026     }
12027   }
12028
12029   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12030   return jresult;
12031 }
12032
12033
12034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12035   void * jresult ;
12036   Dali::Quaternion *arg1 = 0 ;
12037   Dali::Quaternion *arg2 = 0 ;
12038   float arg3 ;
12039   Dali::Quaternion result;
12040
12041   arg1 = (Dali::Quaternion *)jarg1;
12042   if (!arg1) {
12043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12044     return 0;
12045   }
12046   arg2 = (Dali::Quaternion *)jarg2;
12047   if (!arg2) {
12048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12049     return 0;
12050   }
12051   arg3 = (float)jarg3;
12052   {
12053     try {
12054       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12055     } catch (std::out_of_range& e) {
12056       {
12057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12058       };
12059     } catch (std::exception& e) {
12060       {
12061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12062       };
12063     } catch (Dali::DaliException e) {
12064       {
12065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12066       };
12067     } catch (...) {
12068       {
12069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12070       };
12071     }
12072   }
12073
12074   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12075   return jresult;
12076 }
12077
12078
12079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12080   void * jresult ;
12081   Dali::Quaternion *arg1 = 0 ;
12082   Dali::Quaternion *arg2 = 0 ;
12083   Dali::Quaternion *arg3 = 0 ;
12084   Dali::Quaternion *arg4 = 0 ;
12085   float arg5 ;
12086   Dali::Quaternion result;
12087
12088   arg1 = (Dali::Quaternion *)jarg1;
12089   if (!arg1) {
12090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12091     return 0;
12092   }
12093   arg2 = (Dali::Quaternion *)jarg2;
12094   if (!arg2) {
12095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12096     return 0;
12097   }
12098   arg3 = (Dali::Quaternion *)jarg3;
12099   if (!arg3) {
12100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12101     return 0;
12102   }
12103   arg4 = (Dali::Quaternion *)jarg4;
12104   if (!arg4) {
12105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12106     return 0;
12107   }
12108   arg5 = (float)jarg5;
12109   {
12110     try {
12111       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12112     } catch (std::out_of_range& e) {
12113       {
12114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12115       };
12116     } catch (std::exception& e) {
12117       {
12118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12119       };
12120     } catch (Dali::DaliException e) {
12121       {
12122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12123       };
12124     } catch (...) {
12125       {
12126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12127       };
12128     }
12129   }
12130
12131   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12132   return jresult;
12133 }
12134
12135
12136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12137   float jresult ;
12138   Dali::Quaternion *arg1 = 0 ;
12139   Dali::Quaternion *arg2 = 0 ;
12140   float result;
12141
12142   arg1 = (Dali::Quaternion *)jarg1;
12143   if (!arg1) {
12144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12145     return 0;
12146   }
12147   arg2 = (Dali::Quaternion *)jarg2;
12148   if (!arg2) {
12149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12150     return 0;
12151   }
12152   {
12153     try {
12154       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12155     } catch (std::out_of_range& e) {
12156       {
12157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12158       };
12159     } catch (std::exception& e) {
12160       {
12161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12162       };
12163     } catch (Dali::DaliException e) {
12164       {
12165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12166       };
12167     } catch (...) {
12168       {
12169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12170       };
12171     }
12172   }
12173
12174   jresult = result;
12175   return jresult;
12176 }
12177
12178
12179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12180   void * jresult ;
12181   Dali::Matrix *result = 0 ;
12182
12183   {
12184     try {
12185       result = (Dali::Matrix *)new Dali::Matrix();
12186     } catch (std::out_of_range& e) {
12187       {
12188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12189       };
12190     } catch (std::exception& e) {
12191       {
12192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12193       };
12194     } catch (Dali::DaliException e) {
12195       {
12196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12197       };
12198     } catch (...) {
12199       {
12200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12201       };
12202     }
12203   }
12204
12205   jresult = (void *)result;
12206   return jresult;
12207 }
12208
12209
12210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12211   void * jresult ;
12212   bool arg1 ;
12213   Dali::Matrix *result = 0 ;
12214
12215   arg1 = jarg1 ? true : false;
12216   {
12217     try {
12218       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12219     } catch (std::out_of_range& e) {
12220       {
12221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12222       };
12223     } catch (std::exception& e) {
12224       {
12225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12226       };
12227     } catch (Dali::DaliException e) {
12228       {
12229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12230       };
12231     } catch (...) {
12232       {
12233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12234       };
12235     }
12236   }
12237
12238   jresult = (void *)result;
12239   return jresult;
12240 }
12241
12242
12243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12244   void * jresult ;
12245   float *arg1 = (float *) 0 ;
12246   Dali::Matrix *result = 0 ;
12247
12248   arg1 = jarg1;
12249   {
12250     try {
12251       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12252     } catch (std::out_of_range& e) {
12253       {
12254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12255       };
12256     } catch (std::exception& e) {
12257       {
12258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12259       };
12260     } catch (Dali::DaliException e) {
12261       {
12262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12263       };
12264     } catch (...) {
12265       {
12266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12267       };
12268     }
12269   }
12270
12271   jresult = (void *)result;
12272
12273
12274   return jresult;
12275 }
12276
12277
12278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12279   void * jresult ;
12280   Dali::Quaternion *arg1 = 0 ;
12281   Dali::Matrix *result = 0 ;
12282
12283   arg1 = (Dali::Quaternion *)jarg1;
12284   if (!arg1) {
12285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12286     return 0;
12287   }
12288   {
12289     try {
12290       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12291     } catch (std::out_of_range& e) {
12292       {
12293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12294       };
12295     } catch (std::exception& e) {
12296       {
12297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12298       };
12299     } catch (Dali::DaliException e) {
12300       {
12301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12302       };
12303     } catch (...) {
12304       {
12305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12306       };
12307     }
12308   }
12309
12310   jresult = (void *)result;
12311   return jresult;
12312 }
12313
12314
12315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12316   void * jresult ;
12317   Dali::Matrix *arg1 = 0 ;
12318   Dali::Matrix *result = 0 ;
12319
12320   arg1 = (Dali::Matrix *)jarg1;
12321   if (!arg1) {
12322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12323     return 0;
12324   }
12325   {
12326     try {
12327       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12328     } catch (std::out_of_range& e) {
12329       {
12330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12331       };
12332     } catch (std::exception& e) {
12333       {
12334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12335       };
12336     } catch (Dali::DaliException e) {
12337       {
12338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12339       };
12340     } catch (...) {
12341       {
12342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12343       };
12344     }
12345   }
12346
12347   jresult = (void *)result;
12348   return jresult;
12349 }
12350
12351
12352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12353   void * jresult ;
12354   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12355   Dali::Matrix *arg2 = 0 ;
12356   Dali::Matrix *result = 0 ;
12357
12358   arg1 = (Dali::Matrix *)jarg1;
12359   arg2 = (Dali::Matrix *)jarg2;
12360   if (!arg2) {
12361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12362     return 0;
12363   }
12364   {
12365     try {
12366       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12367     } catch (std::out_of_range& e) {
12368       {
12369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12370       };
12371     } catch (std::exception& e) {
12372       {
12373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12374       };
12375     } catch (Dali::DaliException e) {
12376       {
12377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12378       };
12379     } catch (...) {
12380       {
12381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12382       };
12383     }
12384   }
12385
12386   jresult = (void *)result;
12387   return jresult;
12388 }
12389
12390
12391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12392   void * jresult ;
12393   Dali::Matrix *result = 0 ;
12394
12395   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12396   jresult = (void *)result;
12397   return jresult;
12398 }
12399
12400
12401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12402   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12403
12404   arg1 = (Dali::Matrix *)jarg1;
12405   {
12406     try {
12407       (arg1)->SetIdentity();
12408     } catch (std::out_of_range& e) {
12409       {
12410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12411       };
12412     } catch (std::exception& e) {
12413       {
12414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12415       };
12416     } catch (Dali::DaliException e) {
12417       {
12418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12419       };
12420     } catch (...) {
12421       {
12422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12423       };
12424     }
12425   }
12426
12427 }
12428
12429
12430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12431   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12432   Dali::Vector3 *arg2 = 0 ;
12433
12434   arg1 = (Dali::Matrix *)jarg1;
12435   arg2 = (Dali::Vector3 *)jarg2;
12436   if (!arg2) {
12437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12438     return ;
12439   }
12440   {
12441     try {
12442       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12443     } catch (std::out_of_range& e) {
12444       {
12445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12446       };
12447     } catch (std::exception& e) {
12448       {
12449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12450       };
12451     } catch (Dali::DaliException e) {
12452       {
12453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12454       };
12455     } catch (...) {
12456       {
12457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12458       };
12459     }
12460   }
12461
12462 }
12463
12464
12465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12466   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12467   Dali::Matrix *arg2 = 0 ;
12468
12469   arg1 = (Dali::Matrix *)jarg1;
12470   arg2 = (Dali::Matrix *)jarg2;
12471   if (!arg2) {
12472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12473     return ;
12474   }
12475   {
12476     try {
12477       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12478     } catch (std::out_of_range& e) {
12479       {
12480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12481       };
12482     } catch (std::exception& e) {
12483       {
12484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12485       };
12486     } catch (Dali::DaliException e) {
12487       {
12488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12489       };
12490     } catch (...) {
12491       {
12492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12493       };
12494     }
12495   }
12496
12497 }
12498
12499
12500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12501   unsigned int jresult ;
12502   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12503   bool result;
12504
12505   arg1 = (Dali::Matrix *)jarg1;
12506   {
12507     try {
12508       result = (bool)(arg1)->Invert();
12509     } catch (std::out_of_range& e) {
12510       {
12511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12512       };
12513     } catch (std::exception& e) {
12514       {
12515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12516       };
12517     } catch (Dali::DaliException e) {
12518       {
12519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12520       };
12521     } catch (...) {
12522       {
12523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12524       };
12525     }
12526   }
12527
12528   jresult = result;
12529   return jresult;
12530 }
12531
12532
12533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12534   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12535
12536   arg1 = (Dali::Matrix *)jarg1;
12537   {
12538     try {
12539       (arg1)->Transpose();
12540     } catch (std::out_of_range& e) {
12541       {
12542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12543       };
12544     } catch (std::exception& e) {
12545       {
12546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12547       };
12548     } catch (Dali::DaliException e) {
12549       {
12550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12551       };
12552     } catch (...) {
12553       {
12554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12555       };
12556     }
12557   }
12558
12559 }
12560
12561
12562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12563   void * jresult ;
12564   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12565   Dali::Vector3 result;
12566
12567   arg1 = (Dali::Matrix *)jarg1;
12568   {
12569     try {
12570       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12571     } catch (std::out_of_range& e) {
12572       {
12573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12574       };
12575     } catch (std::exception& e) {
12576       {
12577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12578       };
12579     } catch (Dali::DaliException e) {
12580       {
12581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12582       };
12583     } catch (...) {
12584       {
12585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12586       };
12587     }
12588   }
12589
12590   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12591   return jresult;
12592 }
12593
12594
12595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12596   void * jresult ;
12597   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12598   Dali::Vector3 result;
12599
12600   arg1 = (Dali::Matrix *)jarg1;
12601   {
12602     try {
12603       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12604     } catch (std::out_of_range& e) {
12605       {
12606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12607       };
12608     } catch (std::exception& e) {
12609       {
12610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12611       };
12612     } catch (Dali::DaliException e) {
12613       {
12614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12615       };
12616     } catch (...) {
12617       {
12618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12619       };
12620     }
12621   }
12622
12623   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12624   return jresult;
12625 }
12626
12627
12628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12629   void * jresult ;
12630   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12631   Dali::Vector3 result;
12632
12633   arg1 = (Dali::Matrix *)jarg1;
12634   {
12635     try {
12636       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12637     } catch (std::out_of_range& e) {
12638       {
12639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12640       };
12641     } catch (std::exception& e) {
12642       {
12643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12644       };
12645     } catch (Dali::DaliException e) {
12646       {
12647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12648       };
12649     } catch (...) {
12650       {
12651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12652       };
12653     }
12654   }
12655
12656   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12657   return jresult;
12658 }
12659
12660
12661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12662   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12663   Dali::Vector3 *arg2 = 0 ;
12664
12665   arg1 = (Dali::Matrix *)jarg1;
12666   arg2 = (Dali::Vector3 *)jarg2;
12667   if (!arg2) {
12668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12669     return ;
12670   }
12671   {
12672     try {
12673       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12674     } catch (std::out_of_range& e) {
12675       {
12676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12677       };
12678     } catch (std::exception& e) {
12679       {
12680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12681       };
12682     } catch (Dali::DaliException e) {
12683       {
12684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12685       };
12686     } catch (...) {
12687       {
12688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12689       };
12690     }
12691   }
12692
12693 }
12694
12695
12696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12697   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12698   Dali::Vector3 *arg2 = 0 ;
12699
12700   arg1 = (Dali::Matrix *)jarg1;
12701   arg2 = (Dali::Vector3 *)jarg2;
12702   if (!arg2) {
12703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12704     return ;
12705   }
12706   {
12707     try {
12708       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12709     } catch (std::out_of_range& e) {
12710       {
12711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12712       };
12713     } catch (std::exception& e) {
12714       {
12715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12716       };
12717     } catch (Dali::DaliException e) {
12718       {
12719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12720       };
12721     } catch (...) {
12722       {
12723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12724       };
12725     }
12726   }
12727
12728 }
12729
12730
12731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12732   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12733   Dali::Vector3 *arg2 = 0 ;
12734
12735   arg1 = (Dali::Matrix *)jarg1;
12736   arg2 = (Dali::Vector3 *)jarg2;
12737   if (!arg2) {
12738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12739     return ;
12740   }
12741   {
12742     try {
12743       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12744     } catch (std::out_of_range& e) {
12745       {
12746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12747       };
12748     } catch (std::exception& e) {
12749       {
12750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12751       };
12752     } catch (Dali::DaliException e) {
12753       {
12754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12755       };
12756     } catch (...) {
12757       {
12758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12759       };
12760     }
12761   }
12762
12763 }
12764
12765
12766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12767   void * jresult ;
12768   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12769   Dali::Vector4 *result = 0 ;
12770
12771   arg1 = (Dali::Matrix *)jarg1;
12772   {
12773     try {
12774       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12775     } catch (std::out_of_range& e) {
12776       {
12777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12778       };
12779     } catch (std::exception& e) {
12780       {
12781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12782       };
12783     } catch (Dali::DaliException e) {
12784       {
12785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12786       };
12787     } catch (...) {
12788       {
12789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12790       };
12791     }
12792   }
12793
12794   jresult = (void *)result;
12795   return jresult;
12796 }
12797
12798
12799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12800   void * jresult ;
12801   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12802   Dali::Vector3 *result = 0 ;
12803
12804   arg1 = (Dali::Matrix *)jarg1;
12805   {
12806     try {
12807       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12808     } catch (std::out_of_range& e) {
12809       {
12810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12811       };
12812     } catch (std::exception& e) {
12813       {
12814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12815       };
12816     } catch (Dali::DaliException e) {
12817       {
12818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12819       };
12820     } catch (...) {
12821       {
12822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12823       };
12824     }
12825   }
12826
12827   jresult = (void *)result;
12828   return jresult;
12829 }
12830
12831
12832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12833   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12834   Dali::Vector4 *arg2 = 0 ;
12835
12836   arg1 = (Dali::Matrix *)jarg1;
12837   arg2 = (Dali::Vector4 *)jarg2;
12838   if (!arg2) {
12839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12840     return ;
12841   }
12842   {
12843     try {
12844       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12845     } catch (std::out_of_range& e) {
12846       {
12847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12848       };
12849     } catch (std::exception& e) {
12850       {
12851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12852       };
12853     } catch (Dali::DaliException e) {
12854       {
12855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12856       };
12857     } catch (...) {
12858       {
12859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12860       };
12861     }
12862   }
12863
12864 }
12865
12866
12867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12868   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12869   Dali::Vector3 *arg2 = 0 ;
12870
12871   arg1 = (Dali::Matrix *)jarg1;
12872   arg2 = (Dali::Vector3 *)jarg2;
12873   if (!arg2) {
12874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12875     return ;
12876   }
12877   {
12878     try {
12879       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12880     } catch (std::out_of_range& e) {
12881       {
12882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12883       };
12884     } catch (std::exception& e) {
12885       {
12886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12887       };
12888     } catch (Dali::DaliException e) {
12889       {
12890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12891       };
12892     } catch (...) {
12893       {
12894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12895       };
12896     }
12897   }
12898
12899 }
12900
12901
12902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12903   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12904
12905   arg1 = (Dali::Matrix *)jarg1;
12906   {
12907     try {
12908       (arg1)->OrthoNormalize();
12909     } catch (std::out_of_range& e) {
12910       {
12911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12912       };
12913     } catch (std::exception& e) {
12914       {
12915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12916       };
12917     } catch (Dali::DaliException e) {
12918       {
12919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12920       };
12921     } catch (...) {
12922       {
12923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12924       };
12925     }
12926   }
12927
12928 }
12929
12930
12931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12932   void * jresult ;
12933   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12934   float *result = 0 ;
12935
12936   arg1 = (Dali::Matrix *)jarg1;
12937   {
12938     try {
12939       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12940     } catch (std::out_of_range& e) {
12941       {
12942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12943       };
12944     } catch (std::exception& e) {
12945       {
12946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12947       };
12948     } catch (Dali::DaliException e) {
12949       {
12950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12951       };
12952     } catch (...) {
12953       {
12954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12955       };
12956     }
12957   }
12958
12959   jresult = (void *)result;
12960   return jresult;
12961 }
12962
12963
12964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12965   Dali::Matrix *arg1 = 0 ;
12966   Dali::Matrix *arg2 = 0 ;
12967   Dali::Matrix *arg3 = 0 ;
12968
12969   arg1 = (Dali::Matrix *)jarg1;
12970   if (!arg1) {
12971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12972     return ;
12973   }
12974   arg2 = (Dali::Matrix *)jarg2;
12975   if (!arg2) {
12976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12977     return ;
12978   }
12979   arg3 = (Dali::Matrix *)jarg3;
12980   if (!arg3) {
12981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12982     return ;
12983   }
12984   {
12985     try {
12986       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12987     } catch (std::out_of_range& e) {
12988       {
12989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12990       };
12991     } catch (std::exception& e) {
12992       {
12993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12994       };
12995     } catch (Dali::DaliException e) {
12996       {
12997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12998       };
12999     } catch (...) {
13000       {
13001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13002       };
13003     }
13004   }
13005
13006 }
13007
13008
13009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13010   Dali::Matrix *arg1 = 0 ;
13011   Dali::Matrix *arg2 = 0 ;
13012   Dali::Quaternion *arg3 = 0 ;
13013
13014   arg1 = (Dali::Matrix *)jarg1;
13015   if (!arg1) {
13016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13017     return ;
13018   }
13019   arg2 = (Dali::Matrix *)jarg2;
13020   if (!arg2) {
13021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13022     return ;
13023   }
13024   arg3 = (Dali::Quaternion *)jarg3;
13025   if (!arg3) {
13026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13027     return ;
13028   }
13029   {
13030     try {
13031       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13032     } catch (std::out_of_range& e) {
13033       {
13034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13035       };
13036     } catch (std::exception& e) {
13037       {
13038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13039       };
13040     } catch (Dali::DaliException e) {
13041       {
13042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13043       };
13044     } catch (...) {
13045       {
13046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13047       };
13048     }
13049   }
13050
13051 }
13052
13053
13054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13055   void * jresult ;
13056   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13057   Dali::Vector4 *arg2 = 0 ;
13058   Dali::Vector4 result;
13059
13060   arg1 = (Dali::Matrix *)jarg1;
13061   arg2 = (Dali::Vector4 *)jarg2;
13062   if (!arg2) {
13063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13064     return 0;
13065   }
13066   {
13067     try {
13068       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13069     } catch (std::out_of_range& e) {
13070       {
13071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13072       };
13073     } catch (std::exception& e) {
13074       {
13075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13076       };
13077     } catch (Dali::DaliException e) {
13078       {
13079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13080       };
13081     } catch (...) {
13082       {
13083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13084       };
13085     }
13086   }
13087
13088   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13089   return jresult;
13090 }
13091
13092
13093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13094   unsigned int jresult ;
13095   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13096   Dali::Matrix *arg2 = 0 ;
13097   bool result;
13098
13099   arg1 = (Dali::Matrix *)jarg1;
13100   arg2 = (Dali::Matrix *)jarg2;
13101   if (!arg2) {
13102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13103     return 0;
13104   }
13105   {
13106     try {
13107       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13108     } catch (std::out_of_range& e) {
13109       {
13110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13111       };
13112     } catch (std::exception& e) {
13113       {
13114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13115       };
13116     } catch (Dali::DaliException e) {
13117       {
13118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13119       };
13120     } catch (...) {
13121       {
13122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13123       };
13124     }
13125   }
13126
13127   jresult = result;
13128   return jresult;
13129 }
13130
13131
13132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13133   unsigned int jresult ;
13134   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13135   Dali::Matrix *arg2 = 0 ;
13136   bool result;
13137
13138   arg1 = (Dali::Matrix *)jarg1;
13139   arg2 = (Dali::Matrix *)jarg2;
13140   if (!arg2) {
13141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13142     return 0;
13143   }
13144   {
13145     try {
13146       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13147     } catch (std::out_of_range& e) {
13148       {
13149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13150       };
13151     } catch (std::exception& e) {
13152       {
13153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13154       };
13155     } catch (Dali::DaliException e) {
13156       {
13157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13158       };
13159     } catch (...) {
13160       {
13161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13162       };
13163     }
13164   }
13165
13166   jresult = result;
13167   return jresult;
13168 }
13169
13170
13171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13172   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13173   Dali::Vector3 *arg2 = 0 ;
13174   Dali::Quaternion *arg3 = 0 ;
13175   Dali::Vector3 *arg4 = 0 ;
13176
13177   arg1 = (Dali::Matrix *)jarg1;
13178   arg2 = (Dali::Vector3 *)jarg2;
13179   if (!arg2) {
13180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13181     return ;
13182   }
13183   arg3 = (Dali::Quaternion *)jarg3;
13184   if (!arg3) {
13185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13186     return ;
13187   }
13188   arg4 = (Dali::Vector3 *)jarg4;
13189   if (!arg4) {
13190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13191     return ;
13192   }
13193   {
13194     try {
13195       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13196     } catch (std::out_of_range& e) {
13197       {
13198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13199       };
13200     } catch (std::exception& e) {
13201       {
13202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13203       };
13204     } catch (Dali::DaliException e) {
13205       {
13206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13207       };
13208     } catch (...) {
13209       {
13210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13211       };
13212     }
13213   }
13214
13215 }
13216
13217
13218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13219   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13220   Dali::Vector3 *arg2 = 0 ;
13221   Dali::Quaternion *arg3 = 0 ;
13222   Dali::Vector3 *arg4 = 0 ;
13223
13224   arg1 = (Dali::Matrix *)jarg1;
13225   arg2 = (Dali::Vector3 *)jarg2;
13226   if (!arg2) {
13227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13228     return ;
13229   }
13230   arg3 = (Dali::Quaternion *)jarg3;
13231   if (!arg3) {
13232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13233     return ;
13234   }
13235   arg4 = (Dali::Vector3 *)jarg4;
13236   if (!arg4) {
13237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13238     return ;
13239   }
13240   {
13241     try {
13242       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13243     } catch (std::out_of_range& e) {
13244       {
13245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13246       };
13247     } catch (std::exception& e) {
13248       {
13249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13250       };
13251     } catch (Dali::DaliException e) {
13252       {
13253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13254       };
13255     } catch (...) {
13256       {
13257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13258       };
13259     }
13260   }
13261
13262 }
13263
13264
13265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13266   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13267   Dali::Vector3 *arg2 = 0 ;
13268   Dali::Vector3 *arg3 = 0 ;
13269   Dali::Vector3 *arg4 = 0 ;
13270   Dali::Vector3 *arg5 = 0 ;
13271
13272   arg1 = (Dali::Matrix *)jarg1;
13273   arg2 = (Dali::Vector3 *)jarg2;
13274   if (!arg2) {
13275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13276     return ;
13277   }
13278   arg3 = (Dali::Vector3 *)jarg3;
13279   if (!arg3) {
13280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13281     return ;
13282   }
13283   arg4 = (Dali::Vector3 *)jarg4;
13284   if (!arg4) {
13285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13286     return ;
13287   }
13288   arg5 = (Dali::Vector3 *)jarg5;
13289   if (!arg5) {
13290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13291     return ;
13292   }
13293   {
13294     try {
13295       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13296     } catch (std::out_of_range& e) {
13297       {
13298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13299       };
13300     } catch (std::exception& e) {
13301       {
13302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13303       };
13304     } catch (Dali::DaliException e) {
13305       {
13306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13307       };
13308     } catch (...) {
13309       {
13310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13311       };
13312     }
13313   }
13314
13315 }
13316
13317
13318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13319   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13320   Dali::Vector3 *arg2 = 0 ;
13321   Dali::Quaternion *arg3 = 0 ;
13322   Dali::Vector3 *arg4 = 0 ;
13323
13324   arg1 = (Dali::Matrix *)jarg1;
13325   arg2 = (Dali::Vector3 *)jarg2;
13326   if (!arg2) {
13327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13328     return ;
13329   }
13330   arg3 = (Dali::Quaternion *)jarg3;
13331   if (!arg3) {
13332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13333     return ;
13334   }
13335   arg4 = (Dali::Vector3 *)jarg4;
13336   if (!arg4) {
13337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13338     return ;
13339   }
13340   {
13341     try {
13342       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13343     } catch (std::out_of_range& e) {
13344       {
13345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13346       };
13347     } catch (std::exception& e) {
13348       {
13349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13350       };
13351     } catch (Dali::DaliException e) {
13352       {
13353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13354       };
13355     } catch (...) {
13356       {
13357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13358       };
13359     }
13360   }
13361
13362 }
13363
13364
13365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13366   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13367
13368   arg1 = (Dali::Matrix *)jarg1;
13369   {
13370     try {
13371       delete arg1;
13372     } catch (std::out_of_range& e) {
13373       {
13374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13375       };
13376     } catch (std::exception& e) {
13377       {
13378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13379       };
13380     } catch (Dali::DaliException e) {
13381       {
13382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13383       };
13384     } catch (...) {
13385       {
13386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13387       };
13388     }
13389   }
13390
13391 }
13392
13393
13394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13395   void * jresult ;
13396   Dali::Matrix3 *result = 0 ;
13397
13398   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13399   jresult = (void *)result;
13400   return jresult;
13401 }
13402
13403
13404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13405   void * jresult ;
13406   Dali::Matrix3 *result = 0 ;
13407
13408   {
13409     try {
13410       result = (Dali::Matrix3 *)new Dali::Matrix3();
13411     } catch (std::out_of_range& e) {
13412       {
13413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13414       };
13415     } catch (std::exception& e) {
13416       {
13417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13418       };
13419     } catch (Dali::DaliException e) {
13420       {
13421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13422       };
13423     } catch (...) {
13424       {
13425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13426       };
13427     }
13428   }
13429
13430   jresult = (void *)result;
13431   return jresult;
13432 }
13433
13434
13435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13436   void * jresult ;
13437   Dali::Matrix3 *arg1 = 0 ;
13438   Dali::Matrix3 *result = 0 ;
13439
13440   arg1 = (Dali::Matrix3 *)jarg1;
13441   if (!arg1) {
13442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13443     return 0;
13444   }
13445   {
13446     try {
13447       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13448     } catch (std::out_of_range& e) {
13449       {
13450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13451       };
13452     } catch (std::exception& e) {
13453       {
13454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13455       };
13456     } catch (Dali::DaliException e) {
13457       {
13458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13459       };
13460     } catch (...) {
13461       {
13462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13463       };
13464     }
13465   }
13466
13467   jresult = (void *)result;
13468   return jresult;
13469 }
13470
13471
13472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13473   void * jresult ;
13474   Dali::Matrix *arg1 = 0 ;
13475   Dali::Matrix3 *result = 0 ;
13476
13477   arg1 = (Dali::Matrix *)jarg1;
13478   if (!arg1) {
13479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13480     return 0;
13481   }
13482   {
13483     try {
13484       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13485     } catch (std::out_of_range& e) {
13486       {
13487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13488       };
13489     } catch (std::exception& e) {
13490       {
13491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13492       };
13493     } catch (Dali::DaliException e) {
13494       {
13495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13496       };
13497     } catch (...) {
13498       {
13499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13500       };
13501     }
13502   }
13503
13504   jresult = (void *)result;
13505   return jresult;
13506 }
13507
13508
13509 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) {
13510   void * jresult ;
13511   float arg1 ;
13512   float arg2 ;
13513   float arg3 ;
13514   float arg4 ;
13515   float arg5 ;
13516   float arg6 ;
13517   float arg7 ;
13518   float arg8 ;
13519   float arg9 ;
13520   Dali::Matrix3 *result = 0 ;
13521
13522   arg1 = (float)jarg1;
13523   arg2 = (float)jarg2;
13524   arg3 = (float)jarg3;
13525   arg4 = (float)jarg4;
13526   arg5 = (float)jarg5;
13527   arg6 = (float)jarg6;
13528   arg7 = (float)jarg7;
13529   arg8 = (float)jarg8;
13530   arg9 = (float)jarg9;
13531   {
13532     try {
13533       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13534     } catch (std::out_of_range& e) {
13535       {
13536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13537       };
13538     } catch (std::exception& e) {
13539       {
13540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13541       };
13542     } catch (Dali::DaliException e) {
13543       {
13544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13545       };
13546     } catch (...) {
13547       {
13548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13549       };
13550     }
13551   }
13552
13553   jresult = (void *)result;
13554   return jresult;
13555 }
13556
13557
13558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13559   void * jresult ;
13560   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13561   Dali::Matrix3 *arg2 = 0 ;
13562   Dali::Matrix3 *result = 0 ;
13563
13564   arg1 = (Dali::Matrix3 *)jarg1;
13565   arg2 = (Dali::Matrix3 *)jarg2;
13566   if (!arg2) {
13567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13568     return 0;
13569   }
13570   {
13571     try {
13572       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13573     } catch (std::out_of_range& e) {
13574       {
13575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13576       };
13577     } catch (std::exception& e) {
13578       {
13579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13580       };
13581     } catch (Dali::DaliException e) {
13582       {
13583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13584       };
13585     } catch (...) {
13586       {
13587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13588       };
13589     }
13590   }
13591
13592   jresult = (void *)result;
13593   return jresult;
13594 }
13595
13596
13597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13598   void * jresult ;
13599   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13600   Dali::Matrix *arg2 = 0 ;
13601   Dali::Matrix3 *result = 0 ;
13602
13603   arg1 = (Dali::Matrix3 *)jarg1;
13604   arg2 = (Dali::Matrix *)jarg2;
13605   if (!arg2) {
13606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13607     return 0;
13608   }
13609   {
13610     try {
13611       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13612     } catch (std::out_of_range& e) {
13613       {
13614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13615       };
13616     } catch (std::exception& e) {
13617       {
13618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13619       };
13620     } catch (Dali::DaliException e) {
13621       {
13622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13623       };
13624     } catch (...) {
13625       {
13626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13627       };
13628     }
13629   }
13630
13631   jresult = (void *)result;
13632   return jresult;
13633 }
13634
13635
13636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13637   unsigned int jresult ;
13638   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13639   Dali::Matrix3 *arg2 = 0 ;
13640   bool result;
13641
13642   arg1 = (Dali::Matrix3 *)jarg1;
13643   arg2 = (Dali::Matrix3 *)jarg2;
13644   if (!arg2) {
13645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13646     return 0;
13647   }
13648   {
13649     try {
13650       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13651     } catch (std::out_of_range& e) {
13652       {
13653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13654       };
13655     } catch (std::exception& e) {
13656       {
13657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13658       };
13659     } catch (Dali::DaliException e) {
13660       {
13661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13662       };
13663     } catch (...) {
13664       {
13665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13666       };
13667     }
13668   }
13669
13670   jresult = result;
13671   return jresult;
13672 }
13673
13674
13675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13676   unsigned int jresult ;
13677   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13678   Dali::Matrix3 *arg2 = 0 ;
13679   bool result;
13680
13681   arg1 = (Dali::Matrix3 *)jarg1;
13682   arg2 = (Dali::Matrix3 *)jarg2;
13683   if (!arg2) {
13684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13685     return 0;
13686   }
13687   {
13688     try {
13689       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13690     } catch (std::out_of_range& e) {
13691       {
13692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13693       };
13694     } catch (std::exception& e) {
13695       {
13696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13697       };
13698     } catch (Dali::DaliException e) {
13699       {
13700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13701       };
13702     } catch (...) {
13703       {
13704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13705       };
13706     }
13707   }
13708
13709   jresult = result;
13710   return jresult;
13711 }
13712
13713
13714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13715   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13716
13717   arg1 = (Dali::Matrix3 *)jarg1;
13718   {
13719     try {
13720       delete arg1;
13721     } catch (std::out_of_range& e) {
13722       {
13723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13724       };
13725     } catch (std::exception& e) {
13726       {
13727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13728       };
13729     } catch (Dali::DaliException e) {
13730       {
13731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13732       };
13733     } catch (...) {
13734       {
13735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13736       };
13737     }
13738   }
13739
13740 }
13741
13742
13743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13744   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13745
13746   arg1 = (Dali::Matrix3 *)jarg1;
13747   {
13748     try {
13749       (arg1)->SetIdentity();
13750     } catch (std::out_of_range& e) {
13751       {
13752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13753       };
13754     } catch (std::exception& e) {
13755       {
13756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13757       };
13758     } catch (Dali::DaliException e) {
13759       {
13760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13761       };
13762     } catch (...) {
13763       {
13764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13765       };
13766     }
13767   }
13768
13769 }
13770
13771
13772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13773   void * jresult ;
13774   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13775   float *result = 0 ;
13776
13777   arg1 = (Dali::Matrix3 *)jarg1;
13778   {
13779     try {
13780       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13781     } catch (std::out_of_range& e) {
13782       {
13783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13784       };
13785     } catch (std::exception& e) {
13786       {
13787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13788       };
13789     } catch (Dali::DaliException e) {
13790       {
13791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13792       };
13793     } catch (...) {
13794       {
13795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13796       };
13797     }
13798   }
13799
13800   jresult = (void *)result;
13801   return jresult;
13802 }
13803
13804
13805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13806   unsigned int jresult ;
13807   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13808   bool result;
13809
13810   arg1 = (Dali::Matrix3 *)jarg1;
13811   {
13812     try {
13813       result = (bool)(arg1)->Invert();
13814     } catch (std::out_of_range& e) {
13815       {
13816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13817       };
13818     } catch (std::exception& e) {
13819       {
13820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13821       };
13822     } catch (Dali::DaliException e) {
13823       {
13824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13825       };
13826     } catch (...) {
13827       {
13828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13829       };
13830     }
13831   }
13832
13833   jresult = result;
13834   return jresult;
13835 }
13836
13837
13838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13839   unsigned int jresult ;
13840   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13841   bool result;
13842
13843   arg1 = (Dali::Matrix3 *)jarg1;
13844   {
13845     try {
13846       result = (bool)(arg1)->Transpose();
13847     } catch (std::out_of_range& e) {
13848       {
13849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13850       };
13851     } catch (std::exception& e) {
13852       {
13853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13854       };
13855     } catch (Dali::DaliException e) {
13856       {
13857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13858       };
13859     } catch (...) {
13860       {
13861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13862       };
13863     }
13864   }
13865
13866   jresult = result;
13867   return jresult;
13868 }
13869
13870
13871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13872   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13873   float arg2 ;
13874
13875   arg1 = (Dali::Matrix3 *)jarg1;
13876   arg2 = (float)jarg2;
13877   {
13878     try {
13879       (arg1)->Scale(arg2);
13880     } catch (std::out_of_range& e) {
13881       {
13882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13883       };
13884     } catch (std::exception& e) {
13885       {
13886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13887       };
13888     } catch (Dali::DaliException e) {
13889       {
13890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13891       };
13892     } catch (...) {
13893       {
13894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13895       };
13896     }
13897   }
13898
13899 }
13900
13901
13902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13903   float jresult ;
13904   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13905   float result;
13906
13907   arg1 = (Dali::Matrix3 *)jarg1;
13908   {
13909     try {
13910       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13911     } catch (std::out_of_range& e) {
13912       {
13913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13914       };
13915     } catch (std::exception& e) {
13916       {
13917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13918       };
13919     } catch (Dali::DaliException e) {
13920       {
13921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13922       };
13923     } catch (...) {
13924       {
13925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13926       };
13927     }
13928   }
13929
13930   jresult = result;
13931   return jresult;
13932 }
13933
13934
13935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13936   unsigned int jresult ;
13937   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13938   bool result;
13939
13940   arg1 = (Dali::Matrix3 *)jarg1;
13941   {
13942     try {
13943       result = (bool)(arg1)->ScaledInverseTranspose();
13944     } catch (std::out_of_range& e) {
13945       {
13946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13947       };
13948     } catch (std::exception& e) {
13949       {
13950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13951       };
13952     } catch (Dali::DaliException e) {
13953       {
13954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13955       };
13956     } catch (...) {
13957       {
13958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13959       };
13960     }
13961   }
13962
13963   jresult = result;
13964   return jresult;
13965 }
13966
13967
13968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13969   Dali::Matrix3 *arg1 = 0 ;
13970   Dali::Matrix3 *arg2 = 0 ;
13971   Dali::Matrix3 *arg3 = 0 ;
13972
13973   arg1 = (Dali::Matrix3 *)jarg1;
13974   if (!arg1) {
13975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13976     return ;
13977   }
13978   arg2 = (Dali::Matrix3 *)jarg2;
13979   if (!arg2) {
13980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13981     return ;
13982   }
13983   arg3 = (Dali::Matrix3 *)jarg3;
13984   if (!arg3) {
13985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13986     return ;
13987   }
13988   {
13989     try {
13990       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13991     } catch (std::out_of_range& e) {
13992       {
13993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13994       };
13995     } catch (std::exception& e) {
13996       {
13997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13998       };
13999     } catch (Dali::DaliException e) {
14000       {
14001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14002       };
14003     } catch (...) {
14004       {
14005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14006       };
14007     }
14008   }
14009
14010 }
14011
14012
14013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14014   float jresult ;
14015   float arg1 ;
14016   float arg2 ;
14017   float result;
14018
14019   arg1 = (float)jarg1;
14020   arg2 = (float)jarg2;
14021   {
14022     try {
14023       result = (float)Dali::Random::Range(arg1,arg2);
14024     } catch (std::out_of_range& e) {
14025       {
14026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14027       };
14028     } catch (std::exception& e) {
14029       {
14030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14031       };
14032     } catch (Dali::DaliException e) {
14033       {
14034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14035       };
14036     } catch (...) {
14037       {
14038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14039       };
14040     }
14041   }
14042
14043   jresult = result;
14044   return jresult;
14045 }
14046
14047
14048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14049   void * jresult ;
14050   Dali::Vector4 result;
14051
14052   {
14053     try {
14054       result = Dali::Random::Axis();
14055     } catch (std::out_of_range& e) {
14056       {
14057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14058       };
14059     } catch (std::exception& e) {
14060       {
14061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14062       };
14063     } catch (Dali::DaliException e) {
14064       {
14065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14066       };
14067     } catch (...) {
14068       {
14069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14070       };
14071     }
14072   }
14073
14074   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14075   return jresult;
14076 }
14077
14078
14079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14080   void * jresult ;
14081   Dali::AngleAxis *result = 0 ;
14082
14083   {
14084     try {
14085       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14086     } catch (std::out_of_range& e) {
14087       {
14088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14089       };
14090     } catch (std::exception& e) {
14091       {
14092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14093       };
14094     } catch (Dali::DaliException e) {
14095       {
14096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14097       };
14098     } catch (...) {
14099       {
14100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14101       };
14102     }
14103   }
14104
14105   jresult = (void *)result;
14106   return jresult;
14107 }
14108
14109
14110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14111   void * jresult ;
14112   Dali::Radian arg1 ;
14113   Dali::Vector3 *arg2 = 0 ;
14114   Dali::Radian *argp1 ;
14115   Dali::AngleAxis *result = 0 ;
14116
14117   argp1 = (Dali::Radian *)jarg1;
14118   if (!argp1) {
14119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14120     return 0;
14121   }
14122   arg1 = *argp1;
14123   arg2 = (Dali::Vector3 *)jarg2;
14124   if (!arg2) {
14125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14126     return 0;
14127   }
14128   {
14129     try {
14130       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14131     } catch (std::out_of_range& e) {
14132       {
14133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14134       };
14135     } catch (std::exception& e) {
14136       {
14137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14138       };
14139     } catch (Dali::DaliException e) {
14140       {
14141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14142       };
14143     } catch (...) {
14144       {
14145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14146       };
14147     }
14148   }
14149
14150   jresult = (void *)result;
14151   return jresult;
14152 }
14153
14154
14155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14156   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14157   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14158
14159   arg1 = (Dali::AngleAxis *)jarg1;
14160   arg2 = (Dali::Radian *)jarg2;
14161   if (arg1) (arg1)->angle = *arg2;
14162 }
14163
14164
14165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14166   void * jresult ;
14167   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14168   Dali::Radian *result = 0 ;
14169
14170   arg1 = (Dali::AngleAxis *)jarg1;
14171   result = (Dali::Radian *)& ((arg1)->angle);
14172   jresult = (void *)result;
14173   return jresult;
14174 }
14175
14176
14177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14178   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14179   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14180
14181   arg1 = (Dali::AngleAxis *)jarg1;
14182   arg2 = (Dali::Vector3 *)jarg2;
14183   if (arg1) (arg1)->axis = *arg2;
14184 }
14185
14186
14187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14188   void * jresult ;
14189   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14190   Dali::Vector3 *result = 0 ;
14191
14192   arg1 = (Dali::AngleAxis *)jarg1;
14193   result = (Dali::Vector3 *)& ((arg1)->axis);
14194   jresult = (void *)result;
14195   return jresult;
14196 }
14197
14198
14199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14200   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14201
14202   arg1 = (Dali::AngleAxis *)jarg1;
14203   {
14204     try {
14205       delete arg1;
14206     } catch (std::out_of_range& e) {
14207       {
14208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14209       };
14210     } catch (std::exception& e) {
14211       {
14212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14213       };
14214     } catch (Dali::DaliException e) {
14215       {
14216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14217       };
14218     } catch (...) {
14219       {
14220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14221       };
14222     }
14223   }
14224
14225 }
14226
14227
14228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14229   unsigned int jresult ;
14230   Dali::AngleAxis *arg1 = 0 ;
14231   Dali::AngleAxis *arg2 = 0 ;
14232   bool result;
14233
14234   arg1 = (Dali::AngleAxis *)jarg1;
14235   if (!arg1) {
14236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14237     return 0;
14238   }
14239   arg2 = (Dali::AngleAxis *)jarg2;
14240   if (!arg2) {
14241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14242     return 0;
14243   }
14244   {
14245     try {
14246       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14247     } catch (std::out_of_range& e) {
14248       {
14249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14250       };
14251     } catch (std::exception& e) {
14252       {
14253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14254       };
14255     } catch (Dali::DaliException e) {
14256       {
14257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14258       };
14259     } catch (...) {
14260       {
14261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14262       };
14263     }
14264   }
14265
14266   jresult = result;
14267   return jresult;
14268 }
14269
14270
14271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14272   unsigned int jresult ;
14273   unsigned int arg1 ;
14274   unsigned int result;
14275
14276   arg1 = (unsigned int)jarg1;
14277   {
14278     try {
14279       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14280     } catch (std::out_of_range& e) {
14281       {
14282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14283       };
14284     } catch (std::exception& e) {
14285       {
14286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14287       };
14288     } catch (Dali::DaliException e) {
14289       {
14290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14291       };
14292     } catch (...) {
14293       {
14294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14295       };
14296     }
14297   }
14298
14299   jresult = result;
14300   return jresult;
14301 }
14302
14303
14304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14305   unsigned int jresult ;
14306   unsigned int arg1 ;
14307   bool result;
14308
14309   arg1 = (unsigned int)jarg1;
14310   {
14311     try {
14312       result = (bool)Dali::IsPowerOfTwo(arg1);
14313     } catch (std::out_of_range& e) {
14314       {
14315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14316       };
14317     } catch (std::exception& e) {
14318       {
14319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14320       };
14321     } catch (Dali::DaliException e) {
14322       {
14323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14324       };
14325     } catch (...) {
14326       {
14327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14328       };
14329     }
14330   }
14331
14332   jresult = result;
14333   return jresult;
14334 }
14335
14336
14337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14338   float jresult ;
14339   float arg1 ;
14340   float arg2 ;
14341   float result;
14342
14343   arg1 = (float)jarg1;
14344   arg2 = (float)jarg2;
14345   {
14346     try {
14347       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14348     } catch (std::out_of_range& e) {
14349       {
14350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14351       };
14352     } catch (std::exception& e) {
14353       {
14354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14355       };
14356     } catch (Dali::DaliException e) {
14357       {
14358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14359       };
14360     } catch (...) {
14361       {
14362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14363       };
14364     }
14365   }
14366
14367   jresult = result;
14368   return jresult;
14369 }
14370
14371
14372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14373   unsigned int jresult ;
14374   float arg1 ;
14375   bool result;
14376
14377   arg1 = (float)jarg1;
14378   {
14379     try {
14380       result = (bool)Dali::EqualsZero(arg1);
14381     } catch (std::out_of_range& e) {
14382       {
14383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14384       };
14385     } catch (std::exception& e) {
14386       {
14387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14388       };
14389     } catch (Dali::DaliException e) {
14390       {
14391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14392       };
14393     } catch (...) {
14394       {
14395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14396       };
14397     }
14398   }
14399
14400   jresult = result;
14401   return jresult;
14402 }
14403
14404
14405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14406   unsigned int jresult ;
14407   float arg1 ;
14408   float arg2 ;
14409   bool result;
14410
14411   arg1 = (float)jarg1;
14412   arg2 = (float)jarg2;
14413   {
14414     try {
14415       result = (bool)Dali::Equals(arg1,arg2);
14416     } catch (std::out_of_range& e) {
14417       {
14418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14419       };
14420     } catch (std::exception& e) {
14421       {
14422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14423       };
14424     } catch (Dali::DaliException e) {
14425       {
14426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14427       };
14428     } catch (...) {
14429       {
14430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14431       };
14432     }
14433   }
14434
14435   jresult = result;
14436   return jresult;
14437 }
14438
14439
14440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14441   unsigned int jresult ;
14442   float arg1 ;
14443   float arg2 ;
14444   float arg3 ;
14445   bool result;
14446
14447   arg1 = (float)jarg1;
14448   arg2 = (float)jarg2;
14449   arg3 = (float)jarg3;
14450   {
14451     try {
14452       result = (bool)Dali::Equals(arg1,arg2,arg3);
14453     } catch (std::out_of_range& e) {
14454       {
14455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14456       };
14457     } catch (std::exception& e) {
14458       {
14459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14460       };
14461     } catch (Dali::DaliException e) {
14462       {
14463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14464       };
14465     } catch (...) {
14466       {
14467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14468       };
14469     }
14470   }
14471
14472   jresult = result;
14473   return jresult;
14474 }
14475
14476
14477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14478   float jresult ;
14479   float arg1 ;
14480   int arg2 ;
14481   float result;
14482
14483   arg1 = (float)jarg1;
14484   arg2 = (int)jarg2;
14485   {
14486     try {
14487       result = (float)Dali::Round(arg1,arg2);
14488     } catch (std::out_of_range& e) {
14489       {
14490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14491       };
14492     } catch (std::exception& e) {
14493       {
14494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14495       };
14496     } catch (Dali::DaliException e) {
14497       {
14498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14499       };
14500     } catch (...) {
14501       {
14502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14503       };
14504     }
14505   }
14506
14507   jresult = result;
14508   return jresult;
14509 }
14510
14511
14512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14513   float jresult ;
14514   float arg1 ;
14515   float arg2 ;
14516   float arg3 ;
14517   float result;
14518
14519   arg1 = (float)jarg1;
14520   arg2 = (float)jarg2;
14521   arg3 = (float)jarg3;
14522   {
14523     try {
14524       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14525     } catch (std::out_of_range& e) {
14526       {
14527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14528       };
14529     } catch (std::exception& e) {
14530       {
14531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14532       };
14533     } catch (Dali::DaliException e) {
14534       {
14535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14536       };
14537     } catch (...) {
14538       {
14539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14540       };
14541     }
14542   }
14543
14544   jresult = result;
14545   return jresult;
14546 }
14547
14548
14549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14550   float jresult ;
14551   float arg1 ;
14552   float arg2 ;
14553   float arg3 ;
14554   float arg4 ;
14555   float result;
14556
14557   arg1 = (float)jarg1;
14558   arg2 = (float)jarg2;
14559   arg3 = (float)jarg3;
14560   arg4 = (float)jarg4;
14561   {
14562     try {
14563       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14564     } catch (std::out_of_range& e) {
14565       {
14566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14567       };
14568     } catch (std::exception& e) {
14569       {
14570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14571       };
14572     } catch (Dali::DaliException e) {
14573       {
14574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14575       };
14576     } catch (...) {
14577       {
14578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14579       };
14580     }
14581   }
14582
14583   jresult = result;
14584   return jresult;
14585 }
14586
14587
14588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14589   int jresult ;
14590   int result;
14591
14592   result = (int)(int)Dali::Property::INVALID_INDEX;
14593   jresult = result;
14594   return jresult;
14595 }
14596
14597
14598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14599   int jresult ;
14600   int result;
14601
14602   result = (int)(int)Dali::Property::INVALID_KEY;
14603   jresult = result;
14604   return jresult;
14605 }
14606
14607
14608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14609   int jresult ;
14610   int result;
14611
14612   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14613   jresult = result;
14614   return jresult;
14615 }
14616
14617
14618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14619   void * jresult ;
14620   Dali::Handle *arg1 = 0 ;
14621   Dali::Property::Index arg2 ;
14622   Dali::Property *result = 0 ;
14623
14624   arg1 = (Dali::Handle *)jarg1;
14625   if (!arg1) {
14626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14627     return 0;
14628   }
14629   arg2 = (Dali::Property::Index)jarg2;
14630   {
14631     try {
14632       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14633     } catch (std::out_of_range& e) {
14634       {
14635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14636       };
14637     } catch (std::exception& e) {
14638       {
14639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14640       };
14641     } catch (Dali::DaliException e) {
14642       {
14643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14644       };
14645     } catch (...) {
14646       {
14647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14648       };
14649     }
14650   }
14651
14652   jresult = (void *)result;
14653   return jresult;
14654 }
14655
14656
14657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14658   void * jresult ;
14659   Dali::Handle *arg1 = 0 ;
14660   Dali::Property::Index arg2 ;
14661   int arg3 ;
14662   Dali::Property *result = 0 ;
14663
14664   arg1 = (Dali::Handle *)jarg1;
14665   if (!arg1) {
14666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14667     return 0;
14668   }
14669   arg2 = (Dali::Property::Index)jarg2;
14670   arg3 = (int)jarg3;
14671   {
14672     try {
14673       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14674     } catch (std::out_of_range& e) {
14675       {
14676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14677       };
14678     } catch (std::exception& e) {
14679       {
14680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14681       };
14682     } catch (Dali::DaliException e) {
14683       {
14684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14685       };
14686     } catch (...) {
14687       {
14688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14689       };
14690     }
14691   }
14692
14693   jresult = (void *)result;
14694   return jresult;
14695 }
14696
14697
14698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14699   void * jresult ;
14700   Dali::Handle *arg1 = 0 ;
14701   std::string *arg2 = 0 ;
14702   Dali::Property *result = 0 ;
14703
14704   arg1 = (Dali::Handle *)jarg1;
14705   if (!arg1) {
14706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14707     return 0;
14708   }
14709   if (!jarg2) {
14710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14711     return 0;
14712   }
14713   std::string arg2_str(jarg2);
14714   arg2 = &arg2_str;
14715   {
14716     try {
14717       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14718     } catch (std::out_of_range& e) {
14719       {
14720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14721       };
14722     } catch (std::exception& e) {
14723       {
14724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14725       };
14726     } catch (Dali::DaliException e) {
14727       {
14728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14729       };
14730     } catch (...) {
14731       {
14732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14733       };
14734     }
14735   }
14736
14737   jresult = (void *)result;
14738
14739   //argout typemap for const std::string&
14740
14741   return jresult;
14742 }
14743
14744
14745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14746   void * jresult ;
14747   Dali::Handle *arg1 = 0 ;
14748   std::string *arg2 = 0 ;
14749   int arg3 ;
14750   Dali::Property *result = 0 ;
14751
14752   arg1 = (Dali::Handle *)jarg1;
14753   if (!arg1) {
14754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14755     return 0;
14756   }
14757   if (!jarg2) {
14758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14759     return 0;
14760   }
14761   std::string arg2_str(jarg2);
14762   arg2 = &arg2_str;
14763   arg3 = (int)jarg3;
14764   {
14765     try {
14766       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14767     } catch (std::out_of_range& e) {
14768       {
14769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14770       };
14771     } catch (std::exception& e) {
14772       {
14773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14774       };
14775     } catch (Dali::DaliException e) {
14776       {
14777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14778       };
14779     } catch (...) {
14780       {
14781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14782       };
14783     }
14784   }
14785
14786   jresult = (void *)result;
14787
14788   //argout typemap for const std::string&
14789
14790   return jresult;
14791 }
14792
14793
14794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14795   Dali::Property *arg1 = (Dali::Property *) 0 ;
14796
14797   arg1 = (Dali::Property *)jarg1;
14798   {
14799     try {
14800       delete arg1;
14801     } catch (std::out_of_range& e) {
14802       {
14803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14804       };
14805     } catch (std::exception& e) {
14806       {
14807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14808       };
14809     } catch (Dali::DaliException e) {
14810       {
14811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14812       };
14813     } catch (...) {
14814       {
14815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14816       };
14817     }
14818   }
14819
14820 }
14821
14822
14823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14824   Dali::Property *arg1 = (Dali::Property *) 0 ;
14825   Dali::Handle *arg2 = 0 ;
14826
14827   arg1 = (Dali::Property *)jarg1;
14828   arg2 = (Dali::Handle *)jarg2;
14829   if (!arg2) {
14830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14831     return ;
14832   }
14833   if (arg1) (arg1)->object = *arg2;
14834 }
14835
14836
14837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14838   void * jresult ;
14839   Dali::Property *arg1 = (Dali::Property *) 0 ;
14840   Dali::Handle *result = 0 ;
14841
14842   arg1 = (Dali::Property *)jarg1;
14843   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14844   jresult = (void *)result;
14845   return jresult;
14846 }
14847
14848
14849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14850   Dali::Property *arg1 = (Dali::Property *) 0 ;
14851   Dali::Property::Index arg2 ;
14852
14853   arg1 = (Dali::Property *)jarg1;
14854   arg2 = (Dali::Property::Index)jarg2;
14855   if (arg1) (arg1)->propertyIndex = arg2;
14856 }
14857
14858
14859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14860   int jresult ;
14861   Dali::Property *arg1 = (Dali::Property *) 0 ;
14862   Dali::Property::Index result;
14863
14864   arg1 = (Dali::Property *)jarg1;
14865   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14866   jresult = result;
14867   return jresult;
14868 }
14869
14870
14871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14872   Dali::Property *arg1 = (Dali::Property *) 0 ;
14873   int arg2 ;
14874
14875   arg1 = (Dali::Property *)jarg1;
14876   arg2 = (int)jarg2;
14877   if (arg1) (arg1)->componentIndex = arg2;
14878 }
14879
14880
14881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14882   int jresult ;
14883   Dali::Property *arg1 = (Dali::Property *) 0 ;
14884   int result;
14885
14886   arg1 = (Dali::Property *)jarg1;
14887   result = (int) ((arg1)->componentIndex);
14888   jresult = result;
14889   return jresult;
14890 }
14891
14892
14893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14894   void * jresult ;
14895   Dali::Property::Array *result = 0 ;
14896
14897   {
14898     try {
14899       result = (Dali::Property::Array *)new Dali::Property::Array();
14900     } catch (std::out_of_range& e) {
14901       {
14902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14903       };
14904     } catch (std::exception& e) {
14905       {
14906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14907       };
14908     } catch (Dali::DaliException e) {
14909       {
14910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14911       };
14912     } catch (...) {
14913       {
14914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14915       };
14916     }
14917   }
14918
14919   jresult = (void *)result;
14920   return jresult;
14921 }
14922
14923
14924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14925   void * jresult ;
14926   Dali::Property::Array *arg1 = 0 ;
14927   Dali::Property::Array *result = 0 ;
14928
14929   arg1 = (Dali::Property::Array *)jarg1;
14930   if (!arg1) {
14931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14932     return 0;
14933   }
14934   {
14935     try {
14936       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14937     } catch (std::out_of_range& e) {
14938       {
14939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14940       };
14941     } catch (std::exception& e) {
14942       {
14943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14944       };
14945     } catch (Dali::DaliException e) {
14946       {
14947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14948       };
14949     } catch (...) {
14950       {
14951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14952       };
14953     }
14954   }
14955
14956   jresult = (void *)result;
14957   return jresult;
14958 }
14959
14960
14961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14962   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14963
14964   arg1 = (Dali::Property::Array *)jarg1;
14965   {
14966     try {
14967       delete arg1;
14968     } catch (std::out_of_range& e) {
14969       {
14970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14971       };
14972     } catch (std::exception& e) {
14973       {
14974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14975       };
14976     } catch (Dali::DaliException e) {
14977       {
14978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14979       };
14980     } catch (...) {
14981       {
14982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14983       };
14984     }
14985   }
14986
14987 }
14988
14989
14990 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14991   unsigned long jresult ;
14992   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14993   Dali::Property::Array::SizeType result;
14994
14995   arg1 = (Dali::Property::Array *)jarg1;
14996   {
14997     try {
14998       result = ((Dali::Property::Array const *)arg1)->Size();
14999     } catch (std::out_of_range& e) {
15000       {
15001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15002       };
15003     } catch (std::exception& e) {
15004       {
15005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15006       };
15007     } catch (Dali::DaliException e) {
15008       {
15009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15010       };
15011     } catch (...) {
15012       {
15013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15014       };
15015     }
15016   }
15017
15018   jresult = (unsigned long)result;
15019   return jresult;
15020 }
15021
15022
15023 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15024   unsigned long jresult ;
15025   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15026   Dali::Property::Array::SizeType result;
15027
15028   arg1 = (Dali::Property::Array *)jarg1;
15029   {
15030     try {
15031       result = ((Dali::Property::Array const *)arg1)->Count();
15032     } catch (std::out_of_range& e) {
15033       {
15034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15035       };
15036     } catch (std::exception& e) {
15037       {
15038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15039       };
15040     } catch (Dali::DaliException e) {
15041       {
15042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15043       };
15044     } catch (...) {
15045       {
15046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15047       };
15048     }
15049   }
15050
15051   jresult = (unsigned long)result;
15052   return jresult;
15053 }
15054
15055
15056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15057   unsigned int jresult ;
15058   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15059   bool result;
15060
15061   arg1 = (Dali::Property::Array *)jarg1;
15062   {
15063     try {
15064       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15065     } catch (std::out_of_range& e) {
15066       {
15067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15068       };
15069     } catch (std::exception& e) {
15070       {
15071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15072       };
15073     } catch (Dali::DaliException e) {
15074       {
15075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15076       };
15077     } catch (...) {
15078       {
15079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15080       };
15081     }
15082   }
15083
15084   jresult = result;
15085   return jresult;
15086 }
15087
15088
15089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15090   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15091
15092   arg1 = (Dali::Property::Array *)jarg1;
15093   {
15094     try {
15095       (arg1)->Clear();
15096     } catch (std::out_of_range& e) {
15097       {
15098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15099       };
15100     } catch (std::exception& e) {
15101       {
15102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15103       };
15104     } catch (Dali::DaliException e) {
15105       {
15106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15107       };
15108     } catch (...) {
15109       {
15110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15111       };
15112     }
15113   }
15114
15115 }
15116
15117
15118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15119   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15120   Dali::Property::Array::SizeType arg2 ;
15121
15122   arg1 = (Dali::Property::Array *)jarg1;
15123   arg2 = (Dali::Property::Array::SizeType)jarg2;
15124   {
15125     try {
15126       (arg1)->Reserve(arg2);
15127     } catch (std::out_of_range& e) {
15128       {
15129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15130       };
15131     } catch (std::exception& e) {
15132       {
15133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15134       };
15135     } catch (Dali::DaliException e) {
15136       {
15137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15138       };
15139     } catch (...) {
15140       {
15141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15142       };
15143     }
15144   }
15145
15146 }
15147
15148
15149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15150   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15151   Dali::Property::Array::SizeType arg2 ;
15152
15153   arg1 = (Dali::Property::Array *)jarg1;
15154   arg2 = (Dali::Property::Array::SizeType)jarg2;
15155   {
15156     try {
15157       (arg1)->Resize(arg2);
15158     } catch (std::out_of_range& e) {
15159       {
15160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15161       };
15162     } catch (std::exception& e) {
15163       {
15164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15165       };
15166     } catch (Dali::DaliException e) {
15167       {
15168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15169       };
15170     } catch (...) {
15171       {
15172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15173       };
15174     }
15175   }
15176
15177 }
15178
15179
15180 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15181   unsigned long jresult ;
15182   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15183   Dali::Property::Array::SizeType result;
15184
15185   arg1 = (Dali::Property::Array *)jarg1;
15186   {
15187     try {
15188       result = (arg1)->Capacity();
15189     } catch (std::out_of_range& e) {
15190       {
15191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15192       };
15193     } catch (std::exception& e) {
15194       {
15195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15196       };
15197     } catch (Dali::DaliException e) {
15198       {
15199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15200       };
15201     } catch (...) {
15202       {
15203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15204       };
15205     }
15206   }
15207
15208   jresult = (unsigned long)result;
15209   return jresult;
15210 }
15211
15212
15213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15214   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15215   Dali::Property::Value *arg2 = 0 ;
15216
15217   arg1 = (Dali::Property::Array *)jarg1;
15218   arg2 = (Dali::Property::Value *)jarg2;
15219   if (!arg2) {
15220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15221     return ;
15222   }
15223   {
15224     try {
15225       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15226     } catch (std::out_of_range& e) {
15227       {
15228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15229       };
15230     } catch (std::exception& e) {
15231       {
15232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15233       };
15234     } catch (Dali::DaliException e) {
15235       {
15236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15237       };
15238     } catch (...) {
15239       {
15240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15241       };
15242     }
15243   }
15244
15245 }
15246
15247
15248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15249   void * jresult ;
15250   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15251   Dali::Property::Value *arg2 = 0 ;
15252   Dali::Property::Array *result = 0 ;
15253
15254   arg1 = (Dali::Property::Array *)jarg1;
15255   arg2 = (Dali::Property::Value *)jarg2;
15256   if (!arg2) {
15257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15258     return 0;
15259   }
15260   {
15261     try {
15262       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15263     } catch (std::out_of_range& e) {
15264       {
15265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15266       };
15267     } catch (std::exception& e) {
15268       {
15269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15270       };
15271     } catch (Dali::DaliException e) {
15272       {
15273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15274       };
15275     } catch (...) {
15276       {
15277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15278       };
15279     }
15280   }
15281
15282   jresult = (void *)result;
15283   return jresult;
15284 }
15285
15286
15287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15288   void * jresult ;
15289   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15290   Dali::Property::Array::SizeType arg2 ;
15291   Dali::Property::Value *result = 0 ;
15292
15293   arg1 = (Dali::Property::Array *)jarg1;
15294   arg2 = (Dali::Property::Array::SizeType)jarg2;
15295   {
15296     try {
15297       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15298     } catch (std::out_of_range& e) {
15299       {
15300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15301       };
15302     } catch (std::exception& e) {
15303       {
15304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15305       };
15306     } catch (Dali::DaliException e) {
15307       {
15308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15309       };
15310     } catch (...) {
15311       {
15312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15313       };
15314     }
15315   }
15316
15317   jresult = (void *)result;
15318   return jresult;
15319 }
15320
15321
15322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15323   void * jresult ;
15324   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15325   Dali::Property::Array::SizeType arg2 ;
15326   Dali::Property::Value *result = 0 ;
15327
15328   arg1 = (Dali::Property::Array *)jarg1;
15329   arg2 = (Dali::Property::Array::SizeType)jarg2;
15330   {
15331     try {
15332       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15333     } catch (std::out_of_range& e) {
15334       {
15335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15336       };
15337     } catch (std::exception& e) {
15338       {
15339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15340       };
15341     } catch (Dali::DaliException e) {
15342       {
15343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15344       };
15345     } catch (...) {
15346       {
15347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15348       };
15349     }
15350   }
15351
15352   jresult = (void *)result;
15353   return jresult;
15354 }
15355
15356
15357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15358   void * jresult ;
15359   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15360   Dali::Property::Array *arg2 = 0 ;
15361   Dali::Property::Array *result = 0 ;
15362
15363   arg1 = (Dali::Property::Array *)jarg1;
15364   arg2 = (Dali::Property::Array *)jarg2;
15365   if (!arg2) {
15366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15367     return 0;
15368   }
15369   {
15370     try {
15371       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15372     } catch (std::out_of_range& e) {
15373       {
15374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15375       };
15376     } catch (std::exception& e) {
15377       {
15378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15379       };
15380     } catch (Dali::DaliException e) {
15381       {
15382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15383       };
15384     } catch (...) {
15385       {
15386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15387       };
15388     }
15389   }
15390
15391   jresult = (void *)result;
15392   return jresult;
15393 }
15394
15395
15396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15397   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15398   enum Dali::Property::Key::Type arg2 ;
15399
15400   arg1 = (Dali::Property::Key *)jarg1;
15401   arg2 = (enum Dali::Property::Key::Type)jarg2;
15402   if (arg1) (arg1)->type = arg2;
15403 }
15404
15405
15406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15407   int jresult ;
15408   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15409   enum Dali::Property::Key::Type result;
15410
15411   arg1 = (Dali::Property::Key *)jarg1;
15412   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15413   jresult = (int)result;
15414   return jresult;
15415 }
15416
15417
15418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15419   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15420   Dali::Property::Index arg2 ;
15421
15422   arg1 = (Dali::Property::Key *)jarg1;
15423   arg2 = (Dali::Property::Index)jarg2;
15424   if (arg1) (arg1)->indexKey = arg2;
15425 }
15426
15427
15428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15429   int jresult ;
15430   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15431   Dali::Property::Index result;
15432
15433   arg1 = (Dali::Property::Key *)jarg1;
15434   result = (Dali::Property::Index) ((arg1)->indexKey);
15435   jresult = result;
15436   return jresult;
15437 }
15438
15439
15440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15441   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15442   std::string *arg2 = 0 ;
15443
15444   arg1 = (Dali::Property::Key *)jarg1;
15445   if (!jarg2) {
15446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15447     return ;
15448   }
15449   std::string arg2_str(jarg2);
15450   arg2 = &arg2_str;
15451   if (arg1) (arg1)->stringKey = *arg2;
15452
15453   //argout typemap for const std::string&
15454
15455 }
15456
15457
15458 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15459   char * jresult ;
15460   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15461   std::string *result = 0 ;
15462
15463   arg1 = (Dali::Property::Key *)jarg1;
15464   result = (std::string *) & ((arg1)->stringKey);
15465   jresult = SWIG_csharp_string_callback(result->c_str());
15466   return jresult;
15467 }
15468
15469
15470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15471   void * jresult ;
15472   std::string *arg1 = 0 ;
15473   Dali::Property::Key *result = 0 ;
15474
15475   if (!jarg1) {
15476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15477     return 0;
15478   }
15479   std::string arg1_str(jarg1);
15480   arg1 = &arg1_str;
15481   {
15482     try {
15483       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15484     } catch (std::out_of_range& e) {
15485       {
15486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15487       };
15488     } catch (std::exception& e) {
15489       {
15490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15491       };
15492     } catch (Dali::DaliException e) {
15493       {
15494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15495       };
15496     } catch (...) {
15497       {
15498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15499       };
15500     }
15501   }
15502
15503   jresult = (void *)result;
15504
15505   //argout typemap for const std::string&
15506
15507   return jresult;
15508 }
15509
15510
15511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15512   void * jresult ;
15513   Dali::Property::Index arg1 ;
15514   Dali::Property::Key *result = 0 ;
15515
15516   arg1 = (Dali::Property::Index)jarg1;
15517   {
15518     try {
15519       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15520     } catch (std::out_of_range& e) {
15521       {
15522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15523       };
15524     } catch (std::exception& e) {
15525       {
15526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15527       };
15528     } catch (Dali::DaliException e) {
15529       {
15530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15531       };
15532     } catch (...) {
15533       {
15534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15535       };
15536     }
15537   }
15538
15539   jresult = (void *)result;
15540   return jresult;
15541 }
15542
15543
15544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15545   unsigned int jresult ;
15546   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15547   std::string *arg2 = 0 ;
15548   bool result;
15549
15550   arg1 = (Dali::Property::Key *)jarg1;
15551   if (!jarg2) {
15552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15553     return 0;
15554   }
15555   std::string arg2_str(jarg2);
15556   arg2 = &arg2_str;
15557   {
15558     try {
15559       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15560     } catch (std::out_of_range& e) {
15561       {
15562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15563       };
15564     } catch (std::exception& e) {
15565       {
15566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15567       };
15568     } catch (Dali::DaliException e) {
15569       {
15570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15571       };
15572     } catch (...) {
15573       {
15574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15575       };
15576     }
15577   }
15578
15579   jresult = result;
15580
15581   //argout typemap for const std::string&
15582
15583   return jresult;
15584 }
15585
15586
15587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15588   unsigned int jresult ;
15589   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15590   Dali::Property::Index arg2 ;
15591   bool result;
15592
15593   arg1 = (Dali::Property::Key *)jarg1;
15594   arg2 = (Dali::Property::Index)jarg2;
15595   {
15596     try {
15597       result = (bool)(arg1)->operator ==(arg2);
15598     } catch (std::out_of_range& e) {
15599       {
15600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15601       };
15602     } catch (std::exception& e) {
15603       {
15604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15605       };
15606     } catch (Dali::DaliException e) {
15607       {
15608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15609       };
15610     } catch (...) {
15611       {
15612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15613       };
15614     }
15615   }
15616
15617   jresult = result;
15618   return jresult;
15619 }
15620
15621
15622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15623   unsigned int jresult ;
15624   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15625   Dali::Property::Key *arg2 = 0 ;
15626   bool result;
15627
15628   arg1 = (Dali::Property::Key *)jarg1;
15629   arg2 = (Dali::Property::Key *)jarg2;
15630   if (!arg2) {
15631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15632     return 0;
15633   }
15634   {
15635     try {
15636       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15637     } catch (std::out_of_range& e) {
15638       {
15639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15640       };
15641     } catch (std::exception& e) {
15642       {
15643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15644       };
15645     } catch (Dali::DaliException e) {
15646       {
15647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15648       };
15649     } catch (...) {
15650       {
15651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15652       };
15653     }
15654   }
15655
15656   jresult = result;
15657   return jresult;
15658 }
15659
15660
15661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15662   unsigned int jresult ;
15663   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15664   std::string *arg2 = 0 ;
15665   bool result;
15666
15667   arg1 = (Dali::Property::Key *)jarg1;
15668   if (!jarg2) {
15669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15670     return 0;
15671   }
15672   std::string arg2_str(jarg2);
15673   arg2 = &arg2_str;
15674   {
15675     try {
15676       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15677     } catch (std::out_of_range& e) {
15678       {
15679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15680       };
15681     } catch (std::exception& e) {
15682       {
15683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15684       };
15685     } catch (Dali::DaliException e) {
15686       {
15687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15688       };
15689     } catch (...) {
15690       {
15691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15692       };
15693     }
15694   }
15695
15696   jresult = result;
15697
15698   //argout typemap for const std::string&
15699
15700   return jresult;
15701 }
15702
15703
15704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15705   unsigned int jresult ;
15706   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15707   Dali::Property::Index arg2 ;
15708   bool result;
15709
15710   arg1 = (Dali::Property::Key *)jarg1;
15711   arg2 = (Dali::Property::Index)jarg2;
15712   {
15713     try {
15714       result = (bool)(arg1)->operator !=(arg2);
15715     } catch (std::out_of_range& e) {
15716       {
15717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15718       };
15719     } catch (std::exception& e) {
15720       {
15721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15722       };
15723     } catch (Dali::DaliException e) {
15724       {
15725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15726       };
15727     } catch (...) {
15728       {
15729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15730       };
15731     }
15732   }
15733
15734   jresult = result;
15735   return jresult;
15736 }
15737
15738
15739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15740   unsigned int jresult ;
15741   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15742   Dali::Property::Key *arg2 = 0 ;
15743   bool result;
15744
15745   arg1 = (Dali::Property::Key *)jarg1;
15746   arg2 = (Dali::Property::Key *)jarg2;
15747   if (!arg2) {
15748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15749     return 0;
15750   }
15751   {
15752     try {
15753       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15754     } catch (std::out_of_range& e) {
15755       {
15756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15757       };
15758     } catch (std::exception& e) {
15759       {
15760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15761       };
15762     } catch (Dali::DaliException e) {
15763       {
15764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15765       };
15766     } catch (...) {
15767       {
15768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15769       };
15770     }
15771   }
15772
15773   jresult = result;
15774   return jresult;
15775 }
15776
15777
15778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15779   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15780
15781   arg1 = (Dali::Property::Key *)jarg1;
15782   {
15783     try {
15784       delete arg1;
15785     } catch (std::out_of_range& e) {
15786       {
15787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15788       };
15789     } catch (std::exception& e) {
15790       {
15791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15792       };
15793     } catch (Dali::DaliException e) {
15794       {
15795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15796       };
15797     } catch (...) {
15798       {
15799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15800       };
15801     }
15802   }
15803
15804 }
15805
15806
15807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15808   void * jresult ;
15809   Dali::Property::Map *result = 0 ;
15810
15811   {
15812     try {
15813       result = (Dali::Property::Map *)new Dali::Property::Map();
15814     } catch (std::out_of_range& e) {
15815       {
15816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15817       };
15818     } catch (std::exception& e) {
15819       {
15820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15821       };
15822     } catch (Dali::DaliException e) {
15823       {
15824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15825       };
15826     } catch (...) {
15827       {
15828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15829       };
15830     }
15831   }
15832
15833   jresult = (void *)result;
15834   return jresult;
15835 }
15836
15837
15838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15839   void * jresult ;
15840   Dali::Property::Map *arg1 = 0 ;
15841   Dali::Property::Map *result = 0 ;
15842
15843   arg1 = (Dali::Property::Map *)jarg1;
15844   if (!arg1) {
15845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15846     return 0;
15847   }
15848   {
15849     try {
15850       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15851     } catch (std::out_of_range& e) {
15852       {
15853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15854       };
15855     } catch (std::exception& e) {
15856       {
15857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15858       };
15859     } catch (Dali::DaliException e) {
15860       {
15861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15862       };
15863     } catch (...) {
15864       {
15865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15866       };
15867     }
15868   }
15869
15870   jresult = (void *)result;
15871   return jresult;
15872 }
15873
15874
15875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15876   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15877
15878   arg1 = (Dali::Property::Map *)jarg1;
15879   {
15880     try {
15881       delete arg1;
15882     } catch (std::out_of_range& e) {
15883       {
15884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15885       };
15886     } catch (std::exception& e) {
15887       {
15888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15889       };
15890     } catch (Dali::DaliException e) {
15891       {
15892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15893       };
15894     } catch (...) {
15895       {
15896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15897       };
15898     }
15899   }
15900
15901 }
15902
15903
15904 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15905   unsigned long jresult ;
15906   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15907   Dali::Property::Map::SizeType result;
15908
15909   arg1 = (Dali::Property::Map *)jarg1;
15910   {
15911     try {
15912       result = ((Dali::Property::Map const *)arg1)->Count();
15913     } catch (std::out_of_range& e) {
15914       {
15915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15916       };
15917     } catch (std::exception& e) {
15918       {
15919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15920       };
15921     } catch (Dali::DaliException e) {
15922       {
15923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15924       };
15925     } catch (...) {
15926       {
15927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15928       };
15929     }
15930   }
15931
15932   jresult = (unsigned long)result;
15933   return jresult;
15934 }
15935
15936
15937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15938   unsigned int jresult ;
15939   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15940   bool result;
15941
15942   arg1 = (Dali::Property::Map *)jarg1;
15943   {
15944     try {
15945       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15946     } catch (std::out_of_range& e) {
15947       {
15948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15949       };
15950     } catch (std::exception& e) {
15951       {
15952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15953       };
15954     } catch (Dali::DaliException e) {
15955       {
15956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15957       };
15958     } catch (...) {
15959       {
15960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15961       };
15962     }
15963   }
15964
15965   jresult = result;
15966   return jresult;
15967 }
15968
15969
15970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15971   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15972   char *arg2 = (char *) 0 ;
15973   Dali::Property::Value *arg3 = 0 ;
15974
15975   arg1 = (Dali::Property::Map *)jarg1;
15976   arg2 = (char *)jarg2;
15977   arg3 = (Dali::Property::Value *)jarg3;
15978   if (!arg3) {
15979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15980     return ;
15981   }
15982   {
15983     try {
15984       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15985     } catch (std::out_of_range& e) {
15986       {
15987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15988       };
15989     } catch (std::exception& e) {
15990       {
15991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15992       };
15993     } catch (Dali::DaliException e) {
15994       {
15995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15996       };
15997     } catch (...) {
15998       {
15999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16000       };
16001     }
16002   }
16003
16004 }
16005
16006
16007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16008   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16009   Dali::Property::Index arg2 ;
16010   Dali::Property::Value *arg3 = 0 ;
16011
16012   arg1 = (Dali::Property::Map *)jarg1;
16013   arg2 = (Dali::Property::Index)jarg2;
16014   arg3 = (Dali::Property::Value *)jarg3;
16015   if (!arg3) {
16016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16017     return ;
16018   }
16019   {
16020     try {
16021       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16022     } catch (std::out_of_range& e) {
16023       {
16024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16025       };
16026     } catch (std::exception& e) {
16027       {
16028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16029       };
16030     } catch (Dali::DaliException e) {
16031       {
16032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16033       };
16034     } catch (...) {
16035       {
16036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16037       };
16038     }
16039   }
16040
16041 }
16042
16043
16044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16045   void * jresult ;
16046   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16047   char *arg2 = (char *) 0 ;
16048   Dali::Property::Value *arg3 = 0 ;
16049   Dali::Property::Map *result = 0 ;
16050
16051   arg1 = (Dali::Property::Map *)jarg1;
16052   arg2 = (char *)jarg2;
16053   arg3 = (Dali::Property::Value *)jarg3;
16054   if (!arg3) {
16055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16056     return 0;
16057   }
16058   {
16059     try {
16060       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16061     } catch (std::out_of_range& e) {
16062       {
16063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16064       };
16065     } catch (std::exception& e) {
16066       {
16067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16068       };
16069     } catch (Dali::DaliException e) {
16070       {
16071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16072       };
16073     } catch (...) {
16074       {
16075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16076       };
16077     }
16078   }
16079
16080   jresult = (void *)result;
16081   return jresult;
16082 }
16083
16084
16085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16086   void * jresult ;
16087   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16088   Dali::Property::Index arg2 ;
16089   Dali::Property::Value *arg3 = 0 ;
16090   Dali::Property::Map *result = 0 ;
16091
16092   arg1 = (Dali::Property::Map *)jarg1;
16093   arg2 = (Dali::Property::Index)jarg2;
16094   arg3 = (Dali::Property::Value *)jarg3;
16095   if (!arg3) {
16096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16097     return 0;
16098   }
16099   {
16100     try {
16101       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16102     } catch (std::out_of_range& e) {
16103       {
16104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16105       };
16106     } catch (std::exception& e) {
16107       {
16108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16109       };
16110     } catch (Dali::DaliException e) {
16111       {
16112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16113       };
16114     } catch (...) {
16115       {
16116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16117       };
16118     }
16119   }
16120
16121   jresult = (void *)result;
16122   return jresult;
16123 }
16124
16125
16126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16127   void * jresult ;
16128   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16129   Dali::Property::Map::SizeType arg2 ;
16130   Dali::Property::Value *result = 0 ;
16131
16132   arg1 = (Dali::Property::Map *)jarg1;
16133   arg2 = (Dali::Property::Map::SizeType)jarg2;
16134   {
16135     try {
16136       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16137     } catch (std::out_of_range& e) {
16138       {
16139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16140       };
16141     } catch (std::exception& e) {
16142       {
16143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16144       };
16145     } catch (Dali::DaliException e) {
16146       {
16147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16148       };
16149     } catch (...) {
16150       {
16151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16152       };
16153     }
16154   }
16155
16156   jresult = (void *)result;
16157   return jresult;
16158 }
16159
16160
16161 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16162   char * jresult ;
16163   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16164   Dali::Property::Map::SizeType arg2 ;
16165   std::string *result = 0 ;
16166
16167   arg1 = (Dali::Property::Map *)jarg1;
16168   arg2 = (Dali::Property::Map::SizeType)jarg2;
16169   {
16170     try {
16171       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16172     } catch (std::out_of_range& e) {
16173       {
16174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16175       };
16176     } catch (std::exception& e) {
16177       {
16178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16179       };
16180     } catch (Dali::DaliException e) {
16181       {
16182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16183       };
16184     } catch (...) {
16185       {
16186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16187       };
16188     }
16189   }
16190
16191   jresult = SWIG_csharp_string_callback(result->c_str());
16192   return jresult;
16193 }
16194
16195
16196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16197   void * jresult ;
16198   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16199   Dali::Property::Map::SizeType arg2 ;
16200   SwigValueWrapper< Dali::Property::Key > result;
16201
16202   arg1 = (Dali::Property::Map *)jarg1;
16203   arg2 = (Dali::Property::Map::SizeType)jarg2;
16204   {
16205     try {
16206       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16207     } catch (std::out_of_range& e) {
16208       {
16209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16210       };
16211     } catch (std::exception& e) {
16212       {
16213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16214       };
16215     } catch (Dali::DaliException e) {
16216       {
16217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16218       };
16219     } catch (...) {
16220       {
16221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16222       };
16223     }
16224   }
16225
16226   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16227   return jresult;
16228 }
16229
16230
16231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16232   void * jresult ;
16233   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16234   Dali::Property::Map::SizeType arg2 ;
16235   StringValuePair *result = 0 ;
16236
16237   arg1 = (Dali::Property::Map *)jarg1;
16238   arg2 = (Dali::Property::Map::SizeType)jarg2;
16239   {
16240     try {
16241       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16242     } catch (std::out_of_range& e) {
16243       {
16244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16245       };
16246     } catch (std::exception& e) {
16247       {
16248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16249       };
16250     } catch (Dali::DaliException e) {
16251       {
16252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16253       };
16254     } catch (...) {
16255       {
16256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16257       };
16258     }
16259   }
16260
16261   jresult = (void *)result;
16262   return jresult;
16263 }
16264
16265
16266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16267   void * jresult ;
16268   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16269   char *arg2 = (char *) 0 ;
16270   Dali::Property::Value *result = 0 ;
16271
16272   arg1 = (Dali::Property::Map *)jarg1;
16273   arg2 = (char *)jarg2;
16274   {
16275     try {
16276       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16277     } catch (std::out_of_range& e) {
16278       {
16279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16280       };
16281     } catch (std::exception& e) {
16282       {
16283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16284       };
16285     } catch (Dali::DaliException e) {
16286       {
16287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16288       };
16289     } catch (...) {
16290       {
16291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16292       };
16293     }
16294   }
16295
16296   jresult = (void *)result;
16297   return jresult;
16298 }
16299
16300
16301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16302   void * jresult ;
16303   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16304   Dali::Property::Index arg2 ;
16305   Dali::Property::Value *result = 0 ;
16306
16307   arg1 = (Dali::Property::Map *)jarg1;
16308   arg2 = (Dali::Property::Index)jarg2;
16309   {
16310     try {
16311       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16312     } catch (std::out_of_range& e) {
16313       {
16314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16315       };
16316     } catch (std::exception& e) {
16317       {
16318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16319       };
16320     } catch (Dali::DaliException e) {
16321       {
16322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16323       };
16324     } catch (...) {
16325       {
16326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16327       };
16328     }
16329   }
16330
16331   jresult = (void *)result;
16332   return jresult;
16333 }
16334
16335
16336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16337   void * jresult ;
16338   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16339   Dali::Property::Index arg2 ;
16340   std::string *arg3 = 0 ;
16341   Dali::Property::Value *result = 0 ;
16342
16343   arg1 = (Dali::Property::Map *)jarg1;
16344   arg2 = (Dali::Property::Index)jarg2;
16345   if (!jarg3) {
16346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16347     return 0;
16348   }
16349   std::string arg3_str(jarg3);
16350   arg3 = &arg3_str;
16351   {
16352     try {
16353       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16354     } catch (std::out_of_range& e) {
16355       {
16356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16357       };
16358     } catch (std::exception& e) {
16359       {
16360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16361       };
16362     } catch (Dali::DaliException e) {
16363       {
16364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16365       };
16366     } catch (...) {
16367       {
16368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16369       };
16370     }
16371   }
16372
16373   jresult = (void *)result;
16374
16375   //argout typemap for const std::string&
16376
16377   return jresult;
16378 }
16379
16380
16381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16382   void * jresult ;
16383   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16384   std::string *arg2 = 0 ;
16385   Dali::Property::Type arg3 ;
16386   Dali::Property::Value *result = 0 ;
16387
16388   arg1 = (Dali::Property::Map *)jarg1;
16389   if (!jarg2) {
16390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16391     return 0;
16392   }
16393   std::string arg2_str(jarg2);
16394   arg2 = &arg2_str;
16395   arg3 = (Dali::Property::Type)jarg3;
16396   {
16397     try {
16398       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16399     } catch (std::out_of_range& e) {
16400       {
16401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16402       };
16403     } catch (std::exception& e) {
16404       {
16405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16406       };
16407     } catch (Dali::DaliException e) {
16408       {
16409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16410       };
16411     } catch (...) {
16412       {
16413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16414       };
16415     }
16416   }
16417
16418   jresult = (void *)result;
16419
16420   //argout typemap for const std::string&
16421
16422   return jresult;
16423 }
16424
16425
16426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16427   void * jresult ;
16428   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16429   Dali::Property::Index arg2 ;
16430   Dali::Property::Type arg3 ;
16431   Dali::Property::Value *result = 0 ;
16432
16433   arg1 = (Dali::Property::Map *)jarg1;
16434   arg2 = (Dali::Property::Index)jarg2;
16435   arg3 = (Dali::Property::Type)jarg3;
16436   {
16437     try {
16438       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16439     } catch (std::out_of_range& e) {
16440       {
16441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16442       };
16443     } catch (std::exception& e) {
16444       {
16445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16446       };
16447     } catch (Dali::DaliException e) {
16448       {
16449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16450       };
16451     } catch (...) {
16452       {
16453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16454       };
16455     }
16456   }
16457
16458   jresult = (void *)result;
16459   return jresult;
16460 }
16461
16462
16463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16464   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16465
16466   arg1 = (Dali::Property::Map *)jarg1;
16467   {
16468     try {
16469       (arg1)->Clear();
16470     } catch (std::out_of_range& e) {
16471       {
16472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16473       };
16474     } catch (std::exception& e) {
16475       {
16476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16477       };
16478     } catch (Dali::DaliException e) {
16479       {
16480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16481       };
16482     } catch (...) {
16483       {
16484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16485       };
16486     }
16487   }
16488
16489 }
16490
16491
16492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16493   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16494   Dali::Property::Map *arg2 = 0 ;
16495
16496   arg1 = (Dali::Property::Map *)jarg1;
16497   arg2 = (Dali::Property::Map *)jarg2;
16498   if (!arg2) {
16499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16500     return ;
16501   }
16502   {
16503     try {
16504       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16505     } catch (std::out_of_range& e) {
16506       {
16507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16508       };
16509     } catch (std::exception& e) {
16510       {
16511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16512       };
16513     } catch (Dali::DaliException e) {
16514       {
16515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16516       };
16517     } catch (...) {
16518       {
16519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16520       };
16521     }
16522   }
16523
16524 }
16525
16526
16527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16528   void * jresult ;
16529   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16530   std::string *arg2 = 0 ;
16531   Dali::Property::Value *result = 0 ;
16532
16533   arg1 = (Dali::Property::Map *)jarg1;
16534   if (!jarg2) {
16535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16536     return 0;
16537   }
16538   std::string arg2_str(jarg2);
16539   arg2 = &arg2_str;
16540   {
16541     try {
16542       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16543     } catch (std::out_of_range& e) {
16544       {
16545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16546       };
16547     } catch (std::exception& e) {
16548       {
16549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16550       };
16551     } catch (Dali::DaliException e) {
16552       {
16553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16554       };
16555     } catch (...) {
16556       {
16557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16558       };
16559     }
16560   }
16561
16562   jresult = (void *)result;
16563
16564   //argout typemap for const std::string&
16565
16566   return jresult;
16567 }
16568
16569
16570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16571   void * jresult ;
16572   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16573   Dali::Property::Index arg2 ;
16574   Dali::Property::Value *result = 0 ;
16575
16576   arg1 = (Dali::Property::Map *)jarg1;
16577   arg2 = (Dali::Property::Index)jarg2;
16578   {
16579     try {
16580       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16581     } catch (std::out_of_range& e) {
16582       {
16583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16584       };
16585     } catch (std::exception& e) {
16586       {
16587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16588       };
16589     } catch (Dali::DaliException e) {
16590       {
16591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16592       };
16593     } catch (...) {
16594       {
16595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16596       };
16597     }
16598   }
16599
16600   jresult = (void *)result;
16601   return jresult;
16602 }
16603
16604
16605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16606   void * jresult ;
16607   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16608   Dali::Property::Map *arg2 = 0 ;
16609   Dali::Property::Map *result = 0 ;
16610
16611   arg1 = (Dali::Property::Map *)jarg1;
16612   arg2 = (Dali::Property::Map *)jarg2;
16613   if (!arg2) {
16614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16615     return 0;
16616   }
16617   {
16618     try {
16619       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16620     } catch (std::out_of_range& e) {
16621       {
16622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16623       };
16624     } catch (std::exception& e) {
16625       {
16626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16627       };
16628     } catch (Dali::DaliException e) {
16629       {
16630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16631       };
16632     } catch (...) {
16633       {
16634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16635       };
16636     }
16637   }
16638
16639   jresult = (void *)result;
16640   return jresult;
16641 }
16642
16643
16644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16645   void * jresult ;
16646   Dali::Property::Value *result = 0 ;
16647
16648   {
16649     try {
16650       result = (Dali::Property::Value *)new Dali::Property::Value();
16651     } catch (std::out_of_range& e) {
16652       {
16653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16654       };
16655     } catch (std::exception& e) {
16656       {
16657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16658       };
16659     } catch (Dali::DaliException e) {
16660       {
16661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16662       };
16663     } catch (...) {
16664       {
16665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16666       };
16667     }
16668   }
16669
16670   jresult = (void *)result;
16671   return jresult;
16672 }
16673
16674
16675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16676   void * jresult ;
16677   bool arg1 ;
16678   Dali::Property::Value *result = 0 ;
16679
16680   arg1 = jarg1 ? true : false;
16681   {
16682     try {
16683       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16684     } catch (std::out_of_range& e) {
16685       {
16686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16687       };
16688     } catch (std::exception& e) {
16689       {
16690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16691       };
16692     } catch (Dali::DaliException e) {
16693       {
16694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16695       };
16696     } catch (...) {
16697       {
16698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16699       };
16700     }
16701   }
16702
16703   jresult = (void *)result;
16704   return jresult;
16705 }
16706
16707
16708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16709   void * jresult ;
16710   int arg1 ;
16711   Dali::Property::Value *result = 0 ;
16712
16713   arg1 = (int)jarg1;
16714   {
16715     try {
16716       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16717     } catch (std::out_of_range& e) {
16718       {
16719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16720       };
16721     } catch (std::exception& e) {
16722       {
16723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16724       };
16725     } catch (Dali::DaliException e) {
16726       {
16727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16728       };
16729     } catch (...) {
16730       {
16731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16732       };
16733     }
16734   }
16735
16736   jresult = (void *)result;
16737   return jresult;
16738 }
16739
16740
16741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16742   void * jresult ;
16743   float arg1 ;
16744   Dali::Property::Value *result = 0 ;
16745
16746   arg1 = (float)jarg1;
16747   {
16748     try {
16749       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16750     } catch (std::out_of_range& e) {
16751       {
16752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16753       };
16754     } catch (std::exception& e) {
16755       {
16756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16757       };
16758     } catch (Dali::DaliException e) {
16759       {
16760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16761       };
16762     } catch (...) {
16763       {
16764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16765       };
16766     }
16767   }
16768
16769   jresult = (void *)result;
16770   return jresult;
16771 }
16772
16773
16774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16775   void * jresult ;
16776   Dali::Vector2 *arg1 = 0 ;
16777   Dali::Property::Value *result = 0 ;
16778
16779   arg1 = (Dali::Vector2 *)jarg1;
16780   if (!arg1) {
16781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16782     return 0;
16783   }
16784   {
16785     try {
16786       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16787     } catch (std::out_of_range& e) {
16788       {
16789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16790       };
16791     } catch (std::exception& e) {
16792       {
16793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16794       };
16795     } catch (Dali::DaliException e) {
16796       {
16797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16798       };
16799     } catch (...) {
16800       {
16801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16802       };
16803     }
16804   }
16805
16806   jresult = (void *)result;
16807   return jresult;
16808 }
16809
16810
16811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16812   void * jresult ;
16813   Dali::Vector3 *arg1 = 0 ;
16814   Dali::Property::Value *result = 0 ;
16815
16816   arg1 = (Dali::Vector3 *)jarg1;
16817   if (!arg1) {
16818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16819     return 0;
16820   }
16821   {
16822     try {
16823       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16824     } catch (std::out_of_range& e) {
16825       {
16826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16827       };
16828     } catch (std::exception& e) {
16829       {
16830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16831       };
16832     } catch (Dali::DaliException e) {
16833       {
16834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16835       };
16836     } catch (...) {
16837       {
16838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16839       };
16840     }
16841   }
16842
16843   jresult = (void *)result;
16844   return jresult;
16845 }
16846
16847
16848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16849   void * jresult ;
16850   Dali::Vector4 *arg1 = 0 ;
16851   Dali::Property::Value *result = 0 ;
16852
16853   arg1 = (Dali::Vector4 *)jarg1;
16854   if (!arg1) {
16855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16856     return 0;
16857   }
16858   {
16859     try {
16860       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16861     } catch (std::out_of_range& e) {
16862       {
16863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16864       };
16865     } catch (std::exception& e) {
16866       {
16867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16868       };
16869     } catch (Dali::DaliException e) {
16870       {
16871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16872       };
16873     } catch (...) {
16874       {
16875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16876       };
16877     }
16878   }
16879
16880   jresult = (void *)result;
16881   return jresult;
16882 }
16883
16884
16885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16886   void * jresult ;
16887   Dali::Matrix3 *arg1 = 0 ;
16888   Dali::Property::Value *result = 0 ;
16889
16890   arg1 = (Dali::Matrix3 *)jarg1;
16891   if (!arg1) {
16892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16893     return 0;
16894   }
16895   {
16896     try {
16897       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16898     } catch (std::out_of_range& e) {
16899       {
16900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (std::exception& e) {
16903       {
16904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16905       };
16906     } catch (Dali::DaliException e) {
16907       {
16908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16909       };
16910     } catch (...) {
16911       {
16912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16913       };
16914     }
16915   }
16916
16917   jresult = (void *)result;
16918   return jresult;
16919 }
16920
16921
16922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16923   void * jresult ;
16924   Dali::Matrix *arg1 = 0 ;
16925   Dali::Property::Value *result = 0 ;
16926
16927   arg1 = (Dali::Matrix *)jarg1;
16928   if (!arg1) {
16929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16930     return 0;
16931   }
16932   {
16933     try {
16934       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16935     } catch (std::out_of_range& e) {
16936       {
16937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16938       };
16939     } catch (std::exception& e) {
16940       {
16941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16942       };
16943     } catch (Dali::DaliException e) {
16944       {
16945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16946       };
16947     } catch (...) {
16948       {
16949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16950       };
16951     }
16952   }
16953
16954   jresult = (void *)result;
16955   return jresult;
16956 }
16957
16958
16959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16960   void * jresult ;
16961   Dali::Rect< int > *arg1 = 0 ;
16962   Dali::Property::Value *result = 0 ;
16963
16964   arg1 = (Dali::Rect< int > *)jarg1;
16965   if (!arg1) {
16966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16967     return 0;
16968   }
16969   {
16970     try {
16971       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16972     } catch (std::out_of_range& e) {
16973       {
16974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16975       };
16976     } catch (std::exception& e) {
16977       {
16978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16979       };
16980     } catch (Dali::DaliException e) {
16981       {
16982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16983       };
16984     } catch (...) {
16985       {
16986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16987       };
16988     }
16989   }
16990
16991   jresult = (void *)result;
16992   return jresult;
16993 }
16994
16995
16996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16997   void * jresult ;
16998   Dali::AngleAxis *arg1 = 0 ;
16999   Dali::Property::Value *result = 0 ;
17000
17001   arg1 = (Dali::AngleAxis *)jarg1;
17002   if (!arg1) {
17003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17004     return 0;
17005   }
17006   {
17007     try {
17008       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17009     } catch (std::out_of_range& e) {
17010       {
17011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17012       };
17013     } catch (std::exception& e) {
17014       {
17015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17016       };
17017     } catch (Dali::DaliException e) {
17018       {
17019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17020       };
17021     } catch (...) {
17022       {
17023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17024       };
17025     }
17026   }
17027
17028   jresult = (void *)result;
17029   return jresult;
17030 }
17031
17032
17033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17034   void * jresult ;
17035   Dali::Quaternion *arg1 = 0 ;
17036   Dali::Property::Value *result = 0 ;
17037
17038   arg1 = (Dali::Quaternion *)jarg1;
17039   if (!arg1) {
17040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17041     return 0;
17042   }
17043   {
17044     try {
17045       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17046     } catch (std::out_of_range& e) {
17047       {
17048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17049       };
17050     } catch (std::exception& e) {
17051       {
17052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17053       };
17054     } catch (Dali::DaliException e) {
17055       {
17056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17057       };
17058     } catch (...) {
17059       {
17060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17061       };
17062     }
17063   }
17064
17065   jresult = (void *)result;
17066   return jresult;
17067 }
17068
17069
17070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17071   void * jresult ;
17072   std::string *arg1 = 0 ;
17073   Dali::Property::Value *result = 0 ;
17074
17075   if (!jarg1) {
17076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17077     return 0;
17078   }
17079   std::string arg1_str(jarg1);
17080   arg1 = &arg1_str;
17081   {
17082     try {
17083       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17084     } catch (std::out_of_range& e) {
17085       {
17086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17087       };
17088     } catch (std::exception& e) {
17089       {
17090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17091       };
17092     } catch (Dali::DaliException e) {
17093       {
17094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17095       };
17096     } catch (...) {
17097       {
17098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17099       };
17100     }
17101   }
17102
17103   jresult = (void *)result;
17104
17105   //argout typemap for const std::string&
17106
17107   return jresult;
17108 }
17109
17110
17111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17112   void * jresult ;
17113   Dali::Property::Array *arg1 = 0 ;
17114   Dali::Property::Value *result = 0 ;
17115
17116   arg1 = (Dali::Property::Array *)jarg1;
17117   if (!arg1) {
17118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17119     return 0;
17120   }
17121   {
17122     try {
17123       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17124     } catch (std::out_of_range& e) {
17125       {
17126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17127       };
17128     } catch (std::exception& e) {
17129       {
17130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17131       };
17132     } catch (Dali::DaliException e) {
17133       {
17134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17135       };
17136     } catch (...) {
17137       {
17138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17139       };
17140     }
17141   }
17142
17143   jresult = (void *)result;
17144   return jresult;
17145 }
17146
17147
17148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17149   void * jresult ;
17150   Dali::Property::Map *arg1 = 0 ;
17151   Dali::Property::Value *result = 0 ;
17152
17153   arg1 = (Dali::Property::Map *)jarg1;
17154   if (!arg1) {
17155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17156     return 0;
17157   }
17158   {
17159     try {
17160       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17161     } catch (std::out_of_range& e) {
17162       {
17163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17164       };
17165     } catch (std::exception& e) {
17166       {
17167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17168       };
17169     } catch (Dali::DaliException e) {
17170       {
17171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17172       };
17173     } catch (...) {
17174       {
17175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17176       };
17177     }
17178   }
17179
17180   jresult = (void *)result;
17181   return jresult;
17182 }
17183
17184
17185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17186   void * jresult ;
17187   Extents *arg1 = 0 ;
17188   Dali::Property::Value *result = 0 ;
17189
17190   arg1 = (Extents *)jarg1;
17191   if (!arg1) {
17192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17193     return 0;
17194   }
17195   {
17196     try {
17197       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17198     } catch (std::out_of_range& e) {
17199       {
17200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17201       };
17202     } catch (std::exception& e) {
17203       {
17204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17205       };
17206     } catch (...) {
17207       {
17208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17209       };
17210     }
17211   }
17212   jresult = (void *)result;
17213   return jresult;
17214 }
17215
17216
17217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17218   void * jresult ;
17219   Dali::Property::Type arg1 ;
17220   Dali::Property::Value *result = 0 ;
17221
17222   arg1 = (Dali::Property::Type)jarg1;
17223   {
17224     try {
17225       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17226     } catch (std::out_of_range& e) {
17227       {
17228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17229       };
17230     } catch (std::exception& e) {
17231       {
17232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17233       };
17234     } catch (Dali::DaliException e) {
17235       {
17236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17237       };
17238     } catch (...) {
17239       {
17240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17241       };
17242     }
17243   }
17244
17245   jresult = (void *)result;
17246   return jresult;
17247 }
17248
17249
17250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17251   void * jresult ;
17252   Dali::Property::Value *arg1 = 0 ;
17253   Dali::Property::Value *result = 0 ;
17254
17255   arg1 = (Dali::Property::Value *)jarg1;
17256   if (!arg1) {
17257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17258     return 0;
17259   }
17260   {
17261     try {
17262       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17263     } catch (std::out_of_range& e) {
17264       {
17265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17266       };
17267     } catch (std::exception& e) {
17268       {
17269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17270       };
17271     } catch (Dali::DaliException e) {
17272       {
17273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17274       };
17275     } catch (...) {
17276       {
17277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17278       };
17279     }
17280   }
17281
17282   jresult = (void *)result;
17283   return jresult;
17284 }
17285
17286
17287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17288   void * jresult ;
17289   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17290   Dali::Property::Value *arg2 = 0 ;
17291   Dali::Property::Value *result = 0 ;
17292
17293   arg1 = (Dali::Property::Value *)jarg1;
17294   arg2 = (Dali::Property::Value *)jarg2;
17295   if (!arg2) {
17296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17297     return 0;
17298   }
17299   {
17300     try {
17301       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17302     } catch (std::out_of_range& e) {
17303       {
17304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17305       };
17306     } catch (std::exception& e) {
17307       {
17308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17309       };
17310     } catch (Dali::DaliException e) {
17311       {
17312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17313       };
17314     } catch (...) {
17315       {
17316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17317       };
17318     }
17319   }
17320
17321   jresult = (void *)result;
17322   return jresult;
17323 }
17324
17325
17326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17327   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17328
17329   arg1 = (Dali::Property::Value *)jarg1;
17330   {
17331     try {
17332       delete arg1;
17333     } catch (std::out_of_range& e) {
17334       {
17335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17336       };
17337     } catch (std::exception& e) {
17338       {
17339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17340       };
17341     } catch (Dali::DaliException e) {
17342       {
17343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17344       };
17345     } catch (...) {
17346       {
17347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17348       };
17349     }
17350   }
17351
17352 }
17353
17354
17355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17356   int jresult ;
17357   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17358   Dali::Property::Type result;
17359
17360   arg1 = (Dali::Property::Value *)jarg1;
17361   {
17362     try {
17363       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17364     } catch (std::out_of_range& e) {
17365       {
17366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17367       };
17368     } catch (std::exception& e) {
17369       {
17370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17371       };
17372     } catch (Dali::DaliException e) {
17373       {
17374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17375       };
17376     } catch (...) {
17377       {
17378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17379       };
17380     }
17381   }
17382
17383   jresult = (int)result;
17384   return jresult;
17385 }
17386
17387
17388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17389   unsigned int jresult ;
17390   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17391   bool *arg2 = 0 ;
17392   bool result;
17393
17394   arg1 = (Dali::Property::Value *)jarg1;
17395   arg2 = (bool *)jarg2;
17396   {
17397     try {
17398       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17399     } catch (std::out_of_range& e) {
17400       {
17401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17402       };
17403     } catch (std::exception& e) {
17404       {
17405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17406       };
17407     } catch (Dali::DaliException e) {
17408       {
17409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17410       };
17411     } catch (...) {
17412       {
17413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17414       };
17415     }
17416   }
17417
17418   jresult = result;
17419   return jresult;
17420 }
17421
17422
17423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17424   unsigned int jresult ;
17425   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17426   float *arg2 = 0 ;
17427   bool result;
17428
17429   arg1 = (Dali::Property::Value *)jarg1;
17430   arg2 = (float *)jarg2;
17431   {
17432     try {
17433       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17434     } catch (std::out_of_range& e) {
17435       {
17436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17437       };
17438     } catch (std::exception& e) {
17439       {
17440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17441       };
17442     } catch (Dali::DaliException e) {
17443       {
17444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17445       };
17446     } catch (...) {
17447       {
17448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17449       };
17450     }
17451   }
17452
17453   jresult = result;
17454   return jresult;
17455 }
17456
17457
17458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17459   unsigned int jresult ;
17460   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17461   int *arg2 = 0 ;
17462   bool result;
17463
17464   arg1 = (Dali::Property::Value *)jarg1;
17465   arg2 = (int *)jarg2;
17466   {
17467     try {
17468       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17469     } catch (std::out_of_range& e) {
17470       {
17471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17472       };
17473     } catch (std::exception& e) {
17474       {
17475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17476       };
17477     } catch (Dali::DaliException e) {
17478       {
17479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17480       };
17481     } catch (...) {
17482       {
17483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17484       };
17485     }
17486   }
17487
17488   jresult = result;
17489   return jresult;
17490 }
17491
17492
17493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17494   unsigned int jresult ;
17495   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17496   Dali::Rect< int > *arg2 = 0 ;
17497   bool result;
17498
17499   arg1 = (Dali::Property::Value *)jarg1;
17500   arg2 = (Dali::Rect< int > *)jarg2;
17501   if (!arg2) {
17502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17503     return 0;
17504   }
17505   {
17506     try {
17507       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17508     } catch (std::out_of_range& e) {
17509       {
17510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17511       };
17512     } catch (std::exception& e) {
17513       {
17514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17515       };
17516     } catch (Dali::DaliException e) {
17517       {
17518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17519       };
17520     } catch (...) {
17521       {
17522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17523       };
17524     }
17525   }
17526
17527   jresult = result;
17528   return jresult;
17529 }
17530
17531
17532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17533   unsigned int jresult ;
17534   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17535   Dali::Vector2 *arg2 = 0 ;
17536   bool result;
17537
17538   arg1 = (Dali::Property::Value *)jarg1;
17539   arg2 = (Dali::Vector2 *)jarg2;
17540   if (!arg2) {
17541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17542     return 0;
17543   }
17544   {
17545     try {
17546       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17547     } catch (std::out_of_range& e) {
17548       {
17549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17550       };
17551     } catch (std::exception& e) {
17552       {
17553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17554       };
17555     } catch (Dali::DaliException e) {
17556       {
17557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17558       };
17559     } catch (...) {
17560       {
17561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17562       };
17563     }
17564   }
17565
17566   jresult = result;
17567   return jresult;
17568 }
17569
17570
17571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17572   unsigned int jresult ;
17573   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17574   Dali::Vector3 *arg2 = 0 ;
17575   bool result;
17576
17577   arg1 = (Dali::Property::Value *)jarg1;
17578   arg2 = (Dali::Vector3 *)jarg2;
17579   if (!arg2) {
17580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17581     return 0;
17582   }
17583   {
17584     try {
17585       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17586     } catch (std::out_of_range& e) {
17587       {
17588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17589       };
17590     } catch (std::exception& e) {
17591       {
17592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17593       };
17594     } catch (Dali::DaliException e) {
17595       {
17596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17597       };
17598     } catch (...) {
17599       {
17600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17601       };
17602     }
17603   }
17604
17605   jresult = result;
17606   return jresult;
17607 }
17608
17609
17610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17611   unsigned int jresult ;
17612   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17613   Dali::Vector4 *arg2 = 0 ;
17614   bool result;
17615
17616   arg1 = (Dali::Property::Value *)jarg1;
17617   arg2 = (Dali::Vector4 *)jarg2;
17618   if (!arg2) {
17619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17620     return 0;
17621   }
17622   {
17623     try {
17624       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17625     } catch (std::out_of_range& e) {
17626       {
17627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17628       };
17629     } catch (std::exception& e) {
17630       {
17631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17632       };
17633     } catch (Dali::DaliException e) {
17634       {
17635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17636       };
17637     } catch (...) {
17638       {
17639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17640       };
17641     }
17642   }
17643
17644   jresult = result;
17645   return jresult;
17646 }
17647
17648
17649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17650   unsigned int jresult ;
17651   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17652   Dali::Matrix3 *arg2 = 0 ;
17653   bool result;
17654
17655   arg1 = (Dali::Property::Value *)jarg1;
17656   arg2 = (Dali::Matrix3 *)jarg2;
17657   if (!arg2) {
17658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17659     return 0;
17660   }
17661   {
17662     try {
17663       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17664     } catch (std::out_of_range& e) {
17665       {
17666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17667       };
17668     } catch (std::exception& e) {
17669       {
17670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17671       };
17672     } catch (Dali::DaliException e) {
17673       {
17674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17675       };
17676     } catch (...) {
17677       {
17678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17679       };
17680     }
17681   }
17682
17683   jresult = result;
17684   return jresult;
17685 }
17686
17687
17688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17689   unsigned int jresult ;
17690   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17691   Dali::Matrix *arg2 = 0 ;
17692   bool result;
17693
17694   arg1 = (Dali::Property::Value *)jarg1;
17695   arg2 = (Dali::Matrix *)jarg2;
17696   if (!arg2) {
17697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17698     return 0;
17699   }
17700   {
17701     try {
17702       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17703     } catch (std::out_of_range& e) {
17704       {
17705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17706       };
17707     } catch (std::exception& e) {
17708       {
17709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17710       };
17711     } catch (Dali::DaliException e) {
17712       {
17713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17714       };
17715     } catch (...) {
17716       {
17717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17718       };
17719     }
17720   }
17721
17722   jresult = result;
17723   return jresult;
17724 }
17725
17726
17727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17728   unsigned int jresult ;
17729   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17730   Dali::AngleAxis *arg2 = 0 ;
17731   bool result;
17732
17733   arg1 = (Dali::Property::Value *)jarg1;
17734   arg2 = (Dali::AngleAxis *)jarg2;
17735   if (!arg2) {
17736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17737     return 0;
17738   }
17739   {
17740     try {
17741       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17742     } catch (std::out_of_range& e) {
17743       {
17744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17745       };
17746     } catch (std::exception& e) {
17747       {
17748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17749       };
17750     } catch (Dali::DaliException e) {
17751       {
17752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17753       };
17754     } catch (...) {
17755       {
17756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17757       };
17758     }
17759   }
17760
17761   jresult = result;
17762   return jresult;
17763 }
17764
17765
17766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17767   unsigned int jresult ;
17768   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17769   Dali::Quaternion *arg2 = 0 ;
17770   bool result;
17771
17772   arg1 = (Dali::Property::Value *)jarg1;
17773   arg2 = (Dali::Quaternion *)jarg2;
17774   if (!arg2) {
17775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17776     return 0;
17777   }
17778   {
17779     try {
17780       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17781     } catch (std::out_of_range& e) {
17782       {
17783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17784       };
17785     } catch (std::exception& e) {
17786       {
17787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17788       };
17789     } catch (Dali::DaliException e) {
17790       {
17791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17792       };
17793     } catch (...) {
17794       {
17795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17796       };
17797     }
17798   }
17799
17800   jresult = result;
17801   return jresult;
17802 }
17803
17804
17805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17806   unsigned int jresult ;
17807   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17808   std::string *arg2 = 0 ;
17809   bool result;
17810
17811   arg1 = (Dali::Property::Value *)jarg1;
17812
17813   //typemap in
17814   std::string temp;
17815   arg2 = &temp;
17816
17817   {
17818     try {
17819       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17820     } catch (std::out_of_range& e) {
17821       {
17822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17823       };
17824     } catch (std::exception& e) {
17825       {
17826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17827       };
17828     } catch (Dali::DaliException e) {
17829       {
17830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17831       };
17832     } catch (...) {
17833       {
17834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17835       };
17836     }
17837   }
17838
17839   jresult = result;
17840
17841   //Typemap argout in c++ file.
17842   //This will convert c++ string to c# string
17843   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17844
17845   return jresult;
17846 }
17847
17848
17849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17850   unsigned int jresult ;
17851   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17852   Dali::Property::Array *arg2 = 0 ;
17853   bool result;
17854
17855   arg1 = (Dali::Property::Value *)jarg1;
17856   arg2 = (Dali::Property::Array *)jarg2;
17857   if (!arg2) {
17858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17859     return 0;
17860   }
17861   {
17862     try {
17863       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17864     } catch (std::out_of_range& e) {
17865       {
17866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17867       };
17868     } catch (std::exception& e) {
17869       {
17870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17871       };
17872     } catch (Dali::DaliException e) {
17873       {
17874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17875       };
17876     } catch (...) {
17877       {
17878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17879       };
17880     }
17881   }
17882
17883   jresult = result;
17884   return jresult;
17885 }
17886
17887
17888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17889   unsigned int jresult ;
17890   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17891   Dali::Property::Map *arg2 = 0 ;
17892   bool result;
17893
17894   arg1 = (Dali::Property::Value *)jarg1;
17895   arg2 = (Dali::Property::Map *)jarg2;
17896   if (!arg2) {
17897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17898     return 0;
17899   }
17900   {
17901     try {
17902       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17903     } catch (std::out_of_range& e) {
17904       {
17905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17906       };
17907     } catch (std::exception& e) {
17908       {
17909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17910       };
17911     } catch (Dali::DaliException e) {
17912       {
17913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17914       };
17915     } catch (...) {
17916       {
17917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17918       };
17919     }
17920   }
17921
17922   jresult = result;
17923   return jresult;
17924 }
17925
17926
17927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17928   unsigned int jresult ;
17929   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17930   Extents *arg2 = 0 ;
17931   bool result;
17932
17933   arg1 = (Dali::Property::Value *)jarg1;
17934   arg2 = (Extents *)jarg2;
17935   if (!arg2) {
17936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17937     return 0;
17938   }
17939   {
17940     try {
17941       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17942     } catch (std::out_of_range& e) {
17943       {
17944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17945       };
17946     } catch (std::exception& e) {
17947       {
17948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17949       };
17950     } catch (...) {
17951       {
17952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17953       };
17954     }
17955   }
17956   jresult = result;
17957   return jresult;
17958 }
17959
17960
17961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17962   void * jresult ;
17963   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17964   Dali::Property::Array *result = 0 ;
17965
17966   arg1 = (Dali::Property::Value *)jarg1;
17967   {
17968     try {
17969       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17970     } catch (std::out_of_range& e) {
17971       {
17972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17973       };
17974     } catch (std::exception& e) {
17975       {
17976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17977       };
17978     } catch (Dali::DaliException e) {
17979       {
17980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17981       };
17982     } catch (...) {
17983       {
17984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17985       };
17986     }
17987   }
17988
17989   jresult = (void *)result;
17990   return jresult;
17991 }
17992
17993
17994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17995   void * jresult ;
17996   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17997   Dali::Property::Map *result = 0 ;
17998
17999   arg1 = (Dali::Property::Value *)jarg1;
18000   {
18001     try {
18002       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18003     } catch (std::out_of_range& e) {
18004       {
18005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18006       };
18007     } catch (std::exception& e) {
18008       {
18009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18010       };
18011     } catch (Dali::DaliException e) {
18012       {
18013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18014       };
18015     } catch (...) {
18016       {
18017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18018       };
18019     }
18020   }
18021
18022   jresult = (void *)result;
18023   return jresult;
18024 }
18025
18026
18027 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18028   char * jresult ;
18029   Dali::Property::Type arg1 ;
18030   char *result = 0 ;
18031
18032   arg1 = (Dali::Property::Type)jarg1;
18033   {
18034     try {
18035       result = (char *)Dali::PropertyTypes::GetName(arg1);
18036     } catch (std::out_of_range& e) {
18037       {
18038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18039       };
18040     } catch (std::exception& e) {
18041       {
18042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18043       };
18044     } catch (Dali::DaliException e) {
18045       {
18046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18047       };
18048     } catch (...) {
18049       {
18050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18051       };
18052     }
18053   }
18054
18055   jresult = SWIG_csharp_string_callback((const char *)result);
18056   return jresult;
18057 }
18058
18059
18060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18061   unsigned int jresult ;
18062   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18063   std::string *arg2 = 0 ;
18064   Dali::Property::Map *arg3 = 0 ;
18065   bool result;
18066
18067   arg1 = (Dali::BaseObject *)jarg1;
18068   if (!jarg2) {
18069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18070     return 0;
18071   }
18072   std::string arg2_str(jarg2);
18073   arg2 = &arg2_str;
18074   arg3 = (Dali::Property::Map *)jarg3;
18075   if (!arg3) {
18076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18077     return 0;
18078   }
18079   {
18080     try {
18081       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18082     } catch (std::out_of_range& e) {
18083       {
18084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18085       };
18086     } catch (std::exception& e) {
18087       {
18088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18089       };
18090     } catch (Dali::DaliException e) {
18091       {
18092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18093       };
18094     } catch (...) {
18095       {
18096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18097       };
18098     }
18099   }
18100
18101   jresult = result;
18102
18103   //argout typemap for const std::string&
18104
18105   return jresult;
18106 }
18107
18108
18109 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18110   char * jresult ;
18111   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18112   std::string *result = 0 ;
18113
18114   arg1 = (Dali::BaseObject *)jarg1;
18115   {
18116     try {
18117       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18118     } catch (std::out_of_range& e) {
18119       {
18120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18121       };
18122     } catch (std::exception& e) {
18123       {
18124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18125       };
18126     } catch (Dali::DaliException e) {
18127       {
18128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18129       };
18130     } catch (...) {
18131       {
18132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18133       };
18134     }
18135   }
18136
18137   jresult = SWIG_csharp_string_callback(result->c_str());
18138   return jresult;
18139 }
18140
18141
18142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18143   unsigned int jresult ;
18144   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18145   Dali::TypeInfo *arg2 = 0 ;
18146   bool result;
18147
18148   arg1 = (Dali::BaseObject *)jarg1;
18149   arg2 = (Dali::TypeInfo *)jarg2;
18150   if (!arg2) {
18151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18152     return 0;
18153   }
18154   {
18155     try {
18156       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18157     } catch (std::out_of_range& e) {
18158       {
18159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18160       };
18161     } catch (std::exception& e) {
18162       {
18163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18164       };
18165     } catch (Dali::DaliException e) {
18166       {
18167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18168       };
18169     } catch (...) {
18170       {
18171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18172       };
18173     }
18174   }
18175
18176   jresult = result;
18177   return jresult;
18178 }
18179
18180
18181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18182   unsigned int jresult ;
18183   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18184   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18185   std::string *arg3 = 0 ;
18186   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18187   bool result;
18188
18189   arg1 = (Dali::BaseObject *)jarg1;
18190   arg2 = (ConnectionTrackerInterface *)jarg2;
18191   if (!jarg3) {
18192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18193     return 0;
18194   }
18195   std::string arg3_str(jarg3);
18196   arg3 = &arg3_str;
18197   arg4 = (FunctorDelegate *)jarg4;
18198   {
18199     try {
18200       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18201     } catch (std::out_of_range& e) {
18202       {
18203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18204       };
18205     } catch (std::exception& e) {
18206       {
18207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18208       };
18209     } catch (Dali::DaliException e) {
18210       {
18211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18212       };
18213     } catch (...) {
18214       {
18215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18216       };
18217     }
18218   }
18219
18220   jresult = result;
18221
18222   //argout typemap for const std::string&
18223
18224   return jresult;
18225 }
18226
18227
18228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18229   void * jresult ;
18230   Dali::BaseHandle *arg1 = 0 ;
18231   Dali::BaseObject *result = 0 ;
18232
18233   arg1 = (Dali::BaseHandle *)jarg1;
18234   if (!arg1) {
18235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18236     return 0;
18237   }
18238   {
18239     try {
18240       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18241     } catch (std::out_of_range& e) {
18242       {
18243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18244       };
18245     } catch (std::exception& e) {
18246       {
18247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18248       };
18249     } catch (Dali::DaliException e) {
18250       {
18251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18252       };
18253     } catch (...) {
18254       {
18255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18256       };
18257     }
18258   }
18259
18260   jresult = (void *)result;
18261   return jresult;
18262 }
18263
18264
18265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18266   void * jresult ;
18267   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18268   Dali::BaseHandle *result = 0 ;
18269
18270   arg1 = (Dali::BaseObject *)jarg1;
18271   {
18272     try {
18273       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18274     } catch (std::out_of_range& e) {
18275       {
18276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18277       };
18278     } catch (std::exception& e) {
18279       {
18280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18281       };
18282     } catch (Dali::DaliException e) {
18283       {
18284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18285       };
18286     } catch (...) {
18287       {
18288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18289       };
18290     }
18291   }
18292
18293   jresult = (void *)result;
18294   return jresult;
18295 }
18296
18297
18298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18299   void * jresult ;
18300   Dali::BaseHandle *result = 0 ;
18301
18302   {
18303     try {
18304       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18305     } catch (std::out_of_range& e) {
18306       {
18307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18308       };
18309     } catch (std::exception& e) {
18310       {
18311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18312       };
18313     } catch (Dali::DaliException e) {
18314       {
18315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18316       };
18317     } catch (...) {
18318       {
18319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18320       };
18321     }
18322   }
18323
18324   jresult = (void *)result;
18325   return jresult;
18326 }
18327
18328
18329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18330   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18331
18332   arg1 = (Dali::BaseHandle *)jarg1;
18333   {
18334     try {
18335       delete arg1;
18336     } catch (std::out_of_range& e) {
18337       {
18338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18339       };
18340     } catch (std::exception& e) {
18341       {
18342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18343       };
18344     } catch (Dali::DaliException e) {
18345       {
18346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18347       };
18348     } catch (...) {
18349       {
18350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18351       };
18352     }
18353   }
18354
18355 }
18356
18357
18358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18359   void * jresult ;
18360   Dali::BaseHandle *arg1 = 0 ;
18361   Dali::BaseHandle *result = 0 ;
18362
18363   arg1 = (Dali::BaseHandle *)jarg1;
18364   if (!arg1) {
18365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18366     return 0;
18367   }
18368   {
18369     try {
18370       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18371     } catch (std::out_of_range& e) {
18372       {
18373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18374       };
18375     } catch (std::exception& e) {
18376       {
18377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18378       };
18379     } catch (Dali::DaliException e) {
18380       {
18381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18382       };
18383     } catch (...) {
18384       {
18385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18386       };
18387     }
18388   }
18389
18390   jresult = (void *)result;
18391   return jresult;
18392 }
18393
18394
18395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18396   void * jresult ;
18397   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18398   Dali::BaseHandle *arg2 = 0 ;
18399   Dali::BaseHandle *result = 0 ;
18400
18401   arg1 = (Dali::BaseHandle *)jarg1;
18402   arg2 = (Dali::BaseHandle *)jarg2;
18403   if (!arg2) {
18404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18405     return 0;
18406   }
18407   {
18408     try {
18409       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18410     } catch (std::out_of_range& e) {
18411       {
18412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18413       };
18414     } catch (std::exception& e) {
18415       {
18416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18417       };
18418     } catch (Dali::DaliException e) {
18419       {
18420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18421       };
18422     } catch (...) {
18423       {
18424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18425       };
18426     }
18427   }
18428
18429   jresult = (void *)result;
18430   return jresult;
18431 }
18432
18433
18434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18435   unsigned int jresult ;
18436   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18437   std::string *arg2 = 0 ;
18438   Dali::Property::Map *arg3 = 0 ;
18439   bool result;
18440
18441   arg1 = (Dali::BaseHandle *)jarg1;
18442   if (!jarg2) {
18443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18444     return 0;
18445   }
18446   std::string arg2_str(jarg2);
18447   arg2 = &arg2_str;
18448   arg3 = (Dali::Property::Map *)jarg3;
18449   if (!arg3) {
18450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18451     return 0;
18452   }
18453   {
18454     try {
18455       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18456     } catch (std::out_of_range& e) {
18457       {
18458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18459       };
18460     } catch (std::exception& e) {
18461       {
18462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18463       };
18464     } catch (Dali::DaliException e) {
18465       {
18466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18467       };
18468     } catch (...) {
18469       {
18470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18471       };
18472     }
18473   }
18474
18475   jresult = result;
18476
18477   //argout typemap for const std::string&
18478
18479   return jresult;
18480 }
18481
18482
18483 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18484   char * jresult ;
18485   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18486   std::string *result = 0 ;
18487
18488   arg1 = (Dali::BaseHandle *)jarg1;
18489   {
18490     try {
18491       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18492     } catch (std::out_of_range& e) {
18493       {
18494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18495       };
18496     } catch (std::exception& e) {
18497       {
18498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18499       };
18500     } catch (Dali::DaliException e) {
18501       {
18502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18503       };
18504     } catch (...) {
18505       {
18506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18507       };
18508     }
18509   }
18510
18511   jresult = SWIG_csharp_string_callback(result->c_str());
18512   return jresult;
18513 }
18514
18515
18516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18517   unsigned int jresult ;
18518   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18519   Dali::TypeInfo *arg2 = 0 ;
18520   bool result;
18521
18522   arg1 = (Dali::BaseHandle *)jarg1;
18523   arg2 = (Dali::TypeInfo *)jarg2;
18524   if (!arg2) {
18525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18526     return 0;
18527   }
18528   {
18529     try {
18530       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18531     } catch (std::out_of_range& e) {
18532       {
18533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18534       };
18535     } catch (std::exception& e) {
18536       {
18537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18538       };
18539     } catch (Dali::DaliException e) {
18540       {
18541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18542       };
18543     } catch (...) {
18544       {
18545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18546       };
18547     }
18548   }
18549
18550   jresult = result;
18551   return jresult;
18552 }
18553
18554
18555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18556   void * jresult ;
18557   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18558   Dali::BaseObject *result = 0 ;
18559
18560   arg1 = (Dali::BaseHandle *)jarg1;
18561   {
18562     try {
18563       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18564     } catch (std::out_of_range& e) {
18565       {
18566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18567       };
18568     } catch (std::exception& e) {
18569       {
18570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18571       };
18572     } catch (Dali::DaliException e) {
18573       {
18574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18575       };
18576     } catch (...) {
18577       {
18578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18579       };
18580     }
18581   }
18582
18583   jresult = (void *)result;
18584   return jresult;
18585 }
18586
18587
18588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18589   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18590
18591   arg1 = (Dali::BaseHandle *)jarg1;
18592   {
18593     try {
18594       (arg1)->Reset();
18595     } catch (std::out_of_range& e) {
18596       {
18597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18598       };
18599     } catch (std::exception& e) {
18600       {
18601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18602       };
18603     } catch (Dali::DaliException e) {
18604       {
18605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18606       };
18607     } catch (...) {
18608       {
18609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18610       };
18611     }
18612   }
18613
18614 }
18615
18616
18617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18618   unsigned int jresult ;
18619   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18620   Dali::BaseHandle *arg2 = 0 ;
18621   bool result;
18622
18623   arg1 = (Dali::BaseHandle *)jarg1;
18624   arg2 = (Dali::BaseHandle *)jarg2;
18625   if (!arg2) {
18626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18627     return 0;
18628   }
18629   {
18630     try {
18631       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18632     } catch (std::out_of_range& e) {
18633       {
18634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18635       };
18636     } catch (std::exception& e) {
18637       {
18638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18639       };
18640     } catch (Dali::DaliException e) {
18641       {
18642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18643       };
18644     } catch (...) {
18645       {
18646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18647       };
18648     }
18649   }
18650
18651   jresult = result;
18652   return jresult;
18653 }
18654
18655
18656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18657   unsigned int jresult ;
18658   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18659   Dali::BaseHandle *arg2 = 0 ;
18660   bool result;
18661
18662   arg1 = (Dali::BaseHandle *)jarg1;
18663   arg2 = (Dali::BaseHandle *)jarg2;
18664   if (!arg2) {
18665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18666     return 0;
18667   }
18668   {
18669     try {
18670       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18671     } catch (std::out_of_range& e) {
18672       {
18673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18674       };
18675     } catch (std::exception& e) {
18676       {
18677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18678       };
18679     } catch (Dali::DaliException e) {
18680       {
18681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18682       };
18683     } catch (...) {
18684       {
18685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18686       };
18687     }
18688   }
18689
18690   jresult = result;
18691   return jresult;
18692 }
18693
18694
18695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18696   void * jresult ;
18697   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18698   Dali::RefObject *result = 0 ;
18699
18700   arg1 = (Dali::BaseHandle *)jarg1;
18701   {
18702     try {
18703       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18704     } catch (std::out_of_range& e) {
18705       {
18706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18707       };
18708     } catch (std::exception& e) {
18709       {
18710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18711       };
18712     } catch (Dali::DaliException e) {
18713       {
18714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18715       };
18716     } catch (...) {
18717       {
18718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18719       };
18720     }
18721   }
18722
18723   jresult = (void *)result;
18724   return jresult;
18725 }
18726
18727
18728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18729   unsigned int jresult ;
18730   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18731   bool result;
18732
18733   arg1 = (Dali::BaseHandle *)jarg1;
18734   {
18735     try {
18736       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18737     } catch (std::out_of_range& e) {
18738       {
18739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18740       };
18741     } catch (std::exception& e) {
18742       {
18743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18744       };
18745     } catch (Dali::DaliException e) {
18746       {
18747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18748       };
18749     } catch (...) {
18750       {
18751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18752       };
18753     }
18754   }
18755
18756   jresult = result;
18757   return jresult;
18758 }
18759
18760
18761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18762   unsigned int jresult ;
18763   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18764   Dali::BaseHandle *arg2 = 0 ;
18765   bool result;
18766
18767   arg1 = (Dali::BaseHandle *)jarg1;
18768   arg2 = (Dali::BaseHandle *)jarg2;
18769   if (!arg2) {
18770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18771     return 0;
18772   }
18773   {
18774     try {
18775       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18776     } catch (std::out_of_range& e) {
18777       {
18778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18779       };
18780     } catch (std::exception& e) {
18781       {
18782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18783       };
18784     } catch (Dali::DaliException e) {
18785       {
18786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18787       };
18788     } catch (...) {
18789       {
18790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18791       };
18792     }
18793   }
18794
18795   jresult = result;
18796   return jresult;
18797 }
18798
18799
18800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18801   unsigned int jresult ;
18802   Dali::BaseHandle *arg1 = 0 ;
18803   Dali::BaseHandle *arg2 = 0 ;
18804   bool result;
18805
18806   arg1 = (Dali::BaseHandle *)jarg1;
18807   if (!arg1) {
18808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18809     return 0;
18810   }
18811   arg2 = (Dali::BaseHandle *)jarg2;
18812   if (!arg2) {
18813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18814     return 0;
18815   }
18816   {
18817     try {
18818       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18819     } catch (std::out_of_range& e) {
18820       {
18821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18822       };
18823     } catch (std::exception& e) {
18824       {
18825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18826       };
18827     } catch (Dali::DaliException e) {
18828       {
18829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18830       };
18831     } catch (...) {
18832       {
18833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18834       };
18835     }
18836   }
18837
18838   jresult = result;
18839   return jresult;
18840 }
18841
18842
18843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18844   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18845
18846   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18847   {
18848     try {
18849       delete arg1;
18850     } catch (std::out_of_range& e) {
18851       {
18852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18853       };
18854     } catch (std::exception& e) {
18855       {
18856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18857       };
18858     } catch (Dali::DaliException e) {
18859       {
18860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18861       };
18862     } catch (...) {
18863       {
18864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18865       };
18866     }
18867   }
18868
18869 }
18870
18871
18872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18873   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18874   SlotObserver *arg2 = (SlotObserver *) 0 ;
18875   CallbackBase *arg3 = (CallbackBase *) 0 ;
18876
18877   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18878   arg2 = (SlotObserver *)jarg2;
18879   arg3 = (CallbackBase *)jarg3;
18880   {
18881     try {
18882       (arg1)->SignalConnected(arg2,arg3);
18883     } catch (std::out_of_range& e) {
18884       {
18885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18886       };
18887     } catch (std::exception& e) {
18888       {
18889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18890       };
18891     } catch (Dali::DaliException e) {
18892       {
18893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18894       };
18895     } catch (...) {
18896       {
18897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18898       };
18899     }
18900   }
18901
18902 }
18903
18904
18905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18906   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18907
18908   arg1 = (Dali::SignalObserver *)jarg1;
18909   {
18910     try {
18911       delete arg1;
18912     } catch (std::out_of_range& e) {
18913       {
18914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18915       };
18916     } catch (std::exception& e) {
18917       {
18918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18919       };
18920     } catch (Dali::DaliException e) {
18921       {
18922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18923       };
18924     } catch (...) {
18925       {
18926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18927       };
18928     }
18929   }
18930
18931 }
18932
18933
18934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18935   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18936   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18937   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18938
18939   arg1 = (Dali::SignalObserver *)jarg1;
18940   arg2 = (Dali::SlotObserver *)jarg2;
18941   arg3 = (Dali::CallbackBase *)jarg3;
18942   {
18943     try {
18944       (arg1)->SignalDisconnected(arg2,arg3);
18945     } catch (std::out_of_range& e) {
18946       {
18947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18948       };
18949     } catch (std::exception& e) {
18950       {
18951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18952       };
18953     } catch (Dali::DaliException e) {
18954       {
18955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18956       };
18957     } catch (...) {
18958       {
18959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18960       };
18961     }
18962   }
18963
18964 }
18965
18966
18967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18968   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18969
18970   arg1 = (Dali::SlotObserver *)jarg1;
18971   {
18972     try {
18973       delete arg1;
18974     } catch (std::out_of_range& e) {
18975       {
18976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18977       };
18978     } catch (std::exception& e) {
18979       {
18980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18981       };
18982     } catch (Dali::DaliException e) {
18983       {
18984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18985       };
18986     } catch (...) {
18987       {
18988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18989       };
18990     }
18991   }
18992
18993 }
18994
18995
18996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18997   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18998   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18999
19000   arg1 = (Dali::SlotObserver *)jarg1;
19001   arg2 = (Dali::CallbackBase *)jarg2;
19002   {
19003     try {
19004       (arg1)->SlotDisconnected(arg2);
19005     } catch (std::out_of_range& e) {
19006       {
19007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19008       };
19009     } catch (std::exception& e) {
19010       {
19011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19012       };
19013     } catch (Dali::DaliException e) {
19014       {
19015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19016       };
19017     } catch (...) {
19018       {
19019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19020       };
19021     }
19022   }
19023
19024 }
19025
19026
19027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19028   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19029
19030   arg1 = (Dali::ConnectionTracker *)jarg1;
19031   {
19032     try {
19033       delete arg1;
19034     } catch (std::out_of_range& e) {
19035       {
19036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19037       };
19038     } catch (std::exception& e) {
19039       {
19040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19041       };
19042     } catch (Dali::DaliException e) {
19043       {
19044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19045       };
19046     } catch (...) {
19047       {
19048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19049       };
19050     }
19051   }
19052
19053 }
19054
19055
19056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19057   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19058
19059   arg1 = (Dali::ConnectionTracker *)jarg1;
19060   {
19061     try {
19062       (arg1)->DisconnectAll();
19063     } catch (std::out_of_range& e) {
19064       {
19065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19066       };
19067     } catch (std::exception& e) {
19068       {
19069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19070       };
19071     } catch (Dali::DaliException e) {
19072       {
19073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19074       };
19075     } catch (...) {
19076       {
19077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19078       };
19079     }
19080   }
19081
19082 }
19083
19084
19085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19086   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19087   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19088   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19089
19090   arg1 = (Dali::ConnectionTracker *)jarg1;
19091   arg2 = (Dali::SlotObserver *)jarg2;
19092   arg3 = (Dali::CallbackBase *)jarg3;
19093   {
19094     try {
19095       (arg1)->SignalConnected(arg2,arg3);
19096     } catch (std::out_of_range& e) {
19097       {
19098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19099       };
19100     } catch (std::exception& e) {
19101       {
19102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19103       };
19104     } catch (Dali::DaliException e) {
19105       {
19106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19107       };
19108     } catch (...) {
19109       {
19110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19111       };
19112     }
19113   }
19114
19115 }
19116
19117
19118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19119   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19120   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19121   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19122
19123   arg1 = (Dali::ConnectionTracker *)jarg1;
19124   arg2 = (Dali::SlotObserver *)jarg2;
19125   arg3 = (Dali::CallbackBase *)jarg3;
19126   {
19127     try {
19128       (arg1)->SignalDisconnected(arg2,arg3);
19129     } catch (std::out_of_range& e) {
19130       {
19131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19132       };
19133     } catch (std::exception& e) {
19134       {
19135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19136       };
19137     } catch (Dali::DaliException e) {
19138       {
19139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19140       };
19141     } catch (...) {
19142       {
19143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19144       };
19145     }
19146   }
19147
19148 }
19149
19150
19151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19152   unsigned long jresult ;
19153   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19154   std::size_t result;
19155
19156   arg1 = (Dali::ConnectionTracker *)jarg1;
19157   {
19158     try {
19159       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19160     } catch (std::out_of_range& e) {
19161       {
19162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19163       };
19164     } catch (std::exception& e) {
19165       {
19166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19167       };
19168     } catch (Dali::DaliException e) {
19169       {
19170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19171       };
19172     } catch (...) {
19173       {
19174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19175       };
19176     }
19177   }
19178
19179   jresult = (unsigned long)result;
19180   return jresult;
19181 }
19182
19183
19184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19185   void * jresult ;
19186   Dali::ObjectRegistry *result = 0 ;
19187
19188   {
19189     try {
19190       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19191     } catch (std::out_of_range& e) {
19192       {
19193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19194       };
19195     } catch (std::exception& e) {
19196       {
19197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19198       };
19199     } catch (Dali::DaliException e) {
19200       {
19201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19202       };
19203     } catch (...) {
19204       {
19205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19206       };
19207     }
19208   }
19209
19210   jresult = (void *)result;
19211   return jresult;
19212 }
19213
19214
19215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19216   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19217
19218   arg1 = (Dali::ObjectRegistry *)jarg1;
19219   {
19220     try {
19221       delete arg1;
19222     } catch (std::out_of_range& e) {
19223       {
19224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19225       };
19226     } catch (std::exception& e) {
19227       {
19228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19229       };
19230     } catch (Dali::DaliException e) {
19231       {
19232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19233       };
19234     } catch (...) {
19235       {
19236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19237       };
19238     }
19239   }
19240
19241 }
19242
19243
19244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19245   void * jresult ;
19246   Dali::ObjectRegistry *arg1 = 0 ;
19247   Dali::ObjectRegistry *result = 0 ;
19248
19249   arg1 = (Dali::ObjectRegistry *)jarg1;
19250   if (!arg1) {
19251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19252     return 0;
19253   }
19254   {
19255     try {
19256       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19257     } catch (std::out_of_range& e) {
19258       {
19259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19260       };
19261     } catch (std::exception& e) {
19262       {
19263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19264       };
19265     } catch (Dali::DaliException e) {
19266       {
19267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19268       };
19269     } catch (...) {
19270       {
19271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19272       };
19273     }
19274   }
19275
19276   jresult = (void *)result;
19277   return jresult;
19278 }
19279
19280
19281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19282   void * jresult ;
19283   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19284   Dali::ObjectRegistry *arg2 = 0 ;
19285   Dali::ObjectRegistry *result = 0 ;
19286
19287   arg1 = (Dali::ObjectRegistry *)jarg1;
19288   arg2 = (Dali::ObjectRegistry *)jarg2;
19289   if (!arg2) {
19290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19291     return 0;
19292   }
19293   {
19294     try {
19295       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19296     } catch (std::out_of_range& e) {
19297       {
19298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19299       };
19300     } catch (std::exception& e) {
19301       {
19302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19303       };
19304     } catch (Dali::DaliException e) {
19305       {
19306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19307       };
19308     } catch (...) {
19309       {
19310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19311       };
19312     }
19313   }
19314
19315   jresult = (void *)result;
19316   return jresult;
19317 }
19318
19319
19320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19321   void * jresult ;
19322   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19323   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19324
19325   arg1 = (Dali::ObjectRegistry *)jarg1;
19326   {
19327     try {
19328       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19329     } catch (std::out_of_range& e) {
19330       {
19331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19332       };
19333     } catch (std::exception& e) {
19334       {
19335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19336       };
19337     } catch (Dali::DaliException e) {
19338       {
19339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19340       };
19341     } catch (...) {
19342       {
19343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19344       };
19345     }
19346   }
19347
19348   jresult = (void *)result;
19349   return jresult;
19350 }
19351
19352
19353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19354   void * jresult ;
19355   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19356   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19357
19358   arg1 = (Dali::ObjectRegistry *)jarg1;
19359   {
19360     try {
19361       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19362     } catch (std::out_of_range& e) {
19363       {
19364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19365       };
19366     } catch (std::exception& e) {
19367       {
19368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19369       };
19370     } catch (Dali::DaliException e) {
19371       {
19372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19373       };
19374     } catch (...) {
19375       {
19376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19377       };
19378     }
19379   }
19380
19381   jresult = (void *)result;
19382   return jresult;
19383 }
19384
19385
19386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19387   void * jresult ;
19388   Dali::PropertyCondition *result = 0 ;
19389
19390   {
19391     try {
19392       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19393     } catch (std::out_of_range& e) {
19394       {
19395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19396       };
19397     } catch (std::exception& e) {
19398       {
19399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19400       };
19401     } catch (Dali::DaliException e) {
19402       {
19403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19404       };
19405     } catch (...) {
19406       {
19407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19408       };
19409     }
19410   }
19411
19412   jresult = (void *)result;
19413   return jresult;
19414 }
19415
19416
19417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19418   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19419
19420   arg1 = (Dali::PropertyCondition *)jarg1;
19421   {
19422     try {
19423       delete arg1;
19424     } catch (std::out_of_range& e) {
19425       {
19426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19427       };
19428     } catch (std::exception& e) {
19429       {
19430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19431       };
19432     } catch (Dali::DaliException e) {
19433       {
19434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19435       };
19436     } catch (...) {
19437       {
19438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19439       };
19440     }
19441   }
19442
19443 }
19444
19445
19446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19447   void * jresult ;
19448   Dali::PropertyCondition *arg1 = 0 ;
19449   Dali::PropertyCondition *result = 0 ;
19450
19451   arg1 = (Dali::PropertyCondition *)jarg1;
19452   if (!arg1) {
19453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19454     return 0;
19455   }
19456   {
19457     try {
19458       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19459     } catch (std::out_of_range& e) {
19460       {
19461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19462       };
19463     } catch (std::exception& e) {
19464       {
19465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19466       };
19467     } catch (Dali::DaliException e) {
19468       {
19469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19470       };
19471     } catch (...) {
19472       {
19473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19474       };
19475     }
19476   }
19477
19478   jresult = (void *)result;
19479   return jresult;
19480 }
19481
19482
19483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19484   void * jresult ;
19485   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19486   Dali::PropertyCondition *arg2 = 0 ;
19487   Dali::PropertyCondition *result = 0 ;
19488
19489   arg1 = (Dali::PropertyCondition *)jarg1;
19490   arg2 = (Dali::PropertyCondition *)jarg2;
19491   if (!arg2) {
19492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19493     return 0;
19494   }
19495   {
19496     try {
19497       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19498     } catch (std::out_of_range& e) {
19499       {
19500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19501       };
19502     } catch (std::exception& e) {
19503       {
19504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19505       };
19506     } catch (Dali::DaliException e) {
19507       {
19508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19509       };
19510     } catch (...) {
19511       {
19512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19513       };
19514     }
19515   }
19516
19517   jresult = (void *)result;
19518   return jresult;
19519 }
19520
19521
19522 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19523   unsigned long jresult ;
19524   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19525   std::size_t result;
19526
19527   arg1 = (Dali::PropertyCondition *)jarg1;
19528   {
19529     try {
19530       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19531     } catch (std::out_of_range& e) {
19532       {
19533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19534       };
19535     } catch (std::exception& e) {
19536       {
19537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19538       };
19539     } catch (...) {
19540       {
19541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19542       };
19543     }
19544   }
19545   jresult = (unsigned long)result;
19546   return jresult;
19547 }
19548
19549
19550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19551   float jresult ;
19552   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19553   std::size_t arg2 ;
19554   float result;
19555
19556   arg1 = (Dali::PropertyCondition *)jarg1;
19557   arg2 = (std::size_t)jarg2;
19558   {
19559     try {
19560       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19561     } catch (std::out_of_range& e) {
19562       {
19563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19564       };
19565     } catch (std::exception& e) {
19566       {
19567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19568       };
19569     } catch (...) {
19570       {
19571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19572       };
19573     }
19574   }
19575   jresult = result;
19576   return jresult;
19577 }
19578
19579
19580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19581   void * jresult ;
19582   float arg1 ;
19583   Dali::PropertyCondition result;
19584
19585   arg1 = (float)jarg1;
19586   {
19587     try {
19588       result = Dali::LessThanCondition(arg1);
19589     } catch (std::out_of_range& e) {
19590       {
19591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19592       };
19593     } catch (std::exception& e) {
19594       {
19595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19596       };
19597     } catch (Dali::DaliException e) {
19598       {
19599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19600       };
19601     } catch (...) {
19602       {
19603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19604       };
19605     }
19606   }
19607
19608   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19609   return jresult;
19610 }
19611
19612
19613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19614   void * jresult ;
19615   float arg1 ;
19616   Dali::PropertyCondition result;
19617
19618   arg1 = (float)jarg1;
19619   {
19620     try {
19621       result = Dali::GreaterThanCondition(arg1);
19622     } catch (std::out_of_range& e) {
19623       {
19624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19625       };
19626     } catch (std::exception& e) {
19627       {
19628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19629       };
19630     } catch (Dali::DaliException e) {
19631       {
19632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19633       };
19634     } catch (...) {
19635       {
19636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19637       };
19638     }
19639   }
19640
19641   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19642   return jresult;
19643 }
19644
19645
19646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19647   void * jresult ;
19648   float arg1 ;
19649   float arg2 ;
19650   Dali::PropertyCondition result;
19651
19652   arg1 = (float)jarg1;
19653   arg2 = (float)jarg2;
19654   {
19655     try {
19656       result = Dali::InsideCondition(arg1,arg2);
19657     } catch (std::out_of_range& e) {
19658       {
19659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19660       };
19661     } catch (std::exception& e) {
19662       {
19663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19664       };
19665     } catch (Dali::DaliException e) {
19666       {
19667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19668       };
19669     } catch (...) {
19670       {
19671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19672       };
19673     }
19674   }
19675
19676   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19677   return jresult;
19678 }
19679
19680
19681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19682   void * jresult ;
19683   float arg1 ;
19684   float arg2 ;
19685   Dali::PropertyCondition result;
19686
19687   arg1 = (float)jarg1;
19688   arg2 = (float)jarg2;
19689   {
19690     try {
19691       result = Dali::OutsideCondition(arg1,arg2);
19692     } catch (std::out_of_range& e) {
19693       {
19694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19695       };
19696     } catch (std::exception& e) {
19697       {
19698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19699       };
19700     } catch (Dali::DaliException e) {
19701       {
19702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19703       };
19704     } catch (...) {
19705       {
19706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19707       };
19708     }
19709   }
19710
19711   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19712   return jresult;
19713 }
19714
19715
19716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19717   void * jresult ;
19718   float arg1 ;
19719   float arg2 ;
19720   Dali::PropertyCondition result;
19721
19722   arg1 = (float)jarg1;
19723   arg2 = (float)jarg2;
19724   {
19725     try {
19726       result = Dali::StepCondition(arg1,arg2);
19727     } catch (std::out_of_range& e) {
19728       {
19729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19730       };
19731     } catch (std::exception& e) {
19732       {
19733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19734       };
19735     } catch (Dali::DaliException e) {
19736       {
19737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19738       };
19739     } catch (...) {
19740       {
19741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19742       };
19743     }
19744   }
19745
19746   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19747   return jresult;
19748 }
19749
19750
19751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19752   void * jresult ;
19753   float arg1 ;
19754   Dali::PropertyCondition result;
19755
19756   arg1 = (float)jarg1;
19757   {
19758     try {
19759       result = Dali::StepCondition(arg1);
19760     } catch (std::out_of_range& e) {
19761       {
19762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19763       };
19764     } catch (std::exception& e) {
19765       {
19766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19767       };
19768     } catch (Dali::DaliException e) {
19769       {
19770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19771       };
19772     } catch (...) {
19773       {
19774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19775       };
19776     }
19777   }
19778
19779   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19780   return jresult;
19781 }
19782
19783
19784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19785   void * jresult ;
19786   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19787   Dali::PropertyCondition result;
19788
19789   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19790   if (!arg1) {
19791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19792     return 0;
19793   }
19794   {
19795     try {
19796       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19797     } catch (std::out_of_range& e) {
19798       {
19799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19800       };
19801     } catch (std::exception& e) {
19802       {
19803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19804       };
19805     } catch (Dali::DaliException e) {
19806       {
19807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19808       };
19809     } catch (...) {
19810       {
19811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19812       };
19813     }
19814   }
19815
19816   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19817   return jresult;
19818 }
19819
19820
19821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19822   void * jresult ;
19823   Dali::PropertyNotification *result = 0 ;
19824
19825   {
19826     try {
19827       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19828     } catch (std::out_of_range& e) {
19829       {
19830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19831       };
19832     } catch (std::exception& e) {
19833       {
19834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19835       };
19836     } catch (Dali::DaliException e) {
19837       {
19838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19839       };
19840     } catch (...) {
19841       {
19842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19843       };
19844     }
19845   }
19846
19847   jresult = (void *)result;
19848   return jresult;
19849 }
19850
19851
19852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19853   void * jresult ;
19854   Dali::BaseHandle arg1 ;
19855   Dali::BaseHandle *argp1 ;
19856   Dali::PropertyNotification result;
19857
19858   argp1 = (Dali::BaseHandle *)jarg1;
19859   if (!argp1) {
19860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19861     return 0;
19862   }
19863   arg1 = *argp1;
19864   {
19865     try {
19866       result = Dali::PropertyNotification::DownCast(arg1);
19867     } catch (std::out_of_range& e) {
19868       {
19869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19870       };
19871     } catch (std::exception& e) {
19872       {
19873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19874       };
19875     } catch (Dali::DaliException e) {
19876       {
19877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19878       };
19879     } catch (...) {
19880       {
19881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19882       };
19883     }
19884   }
19885
19886   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19887   return jresult;
19888 }
19889
19890
19891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19892   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19893
19894   arg1 = (Dali::PropertyNotification *)jarg1;
19895   {
19896     try {
19897       delete arg1;
19898     } catch (std::out_of_range& e) {
19899       {
19900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19901       };
19902     } catch (std::exception& e) {
19903       {
19904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19905       };
19906     } catch (Dali::DaliException e) {
19907       {
19908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19909       };
19910     } catch (...) {
19911       {
19912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19913       };
19914     }
19915   }
19916
19917 }
19918
19919
19920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19921   void * jresult ;
19922   Dali::PropertyNotification *arg1 = 0 ;
19923   Dali::PropertyNotification *result = 0 ;
19924
19925   arg1 = (Dali::PropertyNotification *)jarg1;
19926   if (!arg1) {
19927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19928     return 0;
19929   }
19930   {
19931     try {
19932       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19933     } catch (std::out_of_range& e) {
19934       {
19935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19936       };
19937     } catch (std::exception& e) {
19938       {
19939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19940       };
19941     } catch (Dali::DaliException e) {
19942       {
19943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19944       };
19945     } catch (...) {
19946       {
19947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19948       };
19949     }
19950   }
19951
19952   jresult = (void *)result;
19953   return jresult;
19954 }
19955
19956
19957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19958   void * jresult ;
19959   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19960   Dali::PropertyNotification *arg2 = 0 ;
19961   Dali::PropertyNotification *result = 0 ;
19962
19963   arg1 = (Dali::PropertyNotification *)jarg1;
19964   arg2 = (Dali::PropertyNotification *)jarg2;
19965   if (!arg2) {
19966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19967     return 0;
19968   }
19969   {
19970     try {
19971       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19972     } catch (std::out_of_range& e) {
19973       {
19974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19975       };
19976     } catch (std::exception& e) {
19977       {
19978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19979       };
19980     } catch (Dali::DaliException e) {
19981       {
19982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19983       };
19984     } catch (...) {
19985       {
19986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19987       };
19988     }
19989   }
19990
19991   jresult = (void *)result;
19992   return jresult;
19993 }
19994
19995
19996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19997   void * jresult ;
19998   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19999   Dali::PropertyCondition result;
20000
20001   arg1 = (Dali::PropertyNotification *)jarg1;
20002   {
20003     try {
20004       result = (arg1)->GetCondition();
20005     } catch (std::out_of_range& e) {
20006       {
20007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20008       };
20009     } catch (std::exception& e) {
20010       {
20011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20012       };
20013     } catch (Dali::DaliException e) {
20014       {
20015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20016       };
20017     } catch (...) {
20018       {
20019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20020       };
20021     }
20022   }
20023
20024   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20025   return jresult;
20026 }
20027
20028
20029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20030   void * jresult ;
20031   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20032   Dali::Handle result;
20033
20034   arg1 = (Dali::PropertyNotification *)jarg1;
20035   {
20036     try {
20037       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20038     } catch (std::out_of_range& e) {
20039       {
20040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20041       };
20042     } catch (std::exception& e) {
20043       {
20044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20045       };
20046     } catch (Dali::DaliException e) {
20047       {
20048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20049       };
20050     } catch (...) {
20051       {
20052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20053       };
20054     }
20055   }
20056
20057   jresult = new Dali::Handle((const Dali::Handle &)result);
20058   return jresult;
20059 }
20060
20061
20062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20063   int jresult ;
20064   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20065   Dali::Property::Index result;
20066
20067   arg1 = (Dali::PropertyNotification *)jarg1;
20068   {
20069     try {
20070       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20071     } catch (std::out_of_range& e) {
20072       {
20073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20074       };
20075     } catch (std::exception& e) {
20076       {
20077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20078       };
20079     } catch (Dali::DaliException e) {
20080       {
20081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20082       };
20083     } catch (...) {
20084       {
20085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20086       };
20087     }
20088   }
20089
20090   jresult = result;
20091   return jresult;
20092 }
20093
20094
20095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20096   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20097   Dali::PropertyNotification::NotifyMode arg2 ;
20098
20099   arg1 = (Dali::PropertyNotification *)jarg1;
20100   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20101   {
20102     try {
20103       (arg1)->SetNotifyMode(arg2);
20104     } catch (std::out_of_range& e) {
20105       {
20106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20107       };
20108     } catch (std::exception& e) {
20109       {
20110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20111       };
20112     } catch (Dali::DaliException e) {
20113       {
20114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20115       };
20116     } catch (...) {
20117       {
20118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20119       };
20120     }
20121   }
20122
20123 }
20124
20125
20126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20127   int jresult ;
20128   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20129   Dali::PropertyNotification::NotifyMode result;
20130
20131   arg1 = (Dali::PropertyNotification *)jarg1;
20132   {
20133     try {
20134       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20135     } catch (std::out_of_range& e) {
20136       {
20137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20138       };
20139     } catch (std::exception& e) {
20140       {
20141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20142       };
20143     } catch (Dali::DaliException e) {
20144       {
20145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20146       };
20147     } catch (...) {
20148       {
20149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20150       };
20151     }
20152   }
20153
20154   jresult = (int)result;
20155   return jresult;
20156 }
20157
20158
20159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20160   unsigned int jresult ;
20161   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20162   bool result;
20163
20164   arg1 = (Dali::PropertyNotification *)jarg1;
20165   {
20166     try {
20167       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20168     } catch (std::out_of_range& e) {
20169       {
20170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20171       };
20172     } catch (std::exception& e) {
20173       {
20174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20175       };
20176     } catch (Dali::DaliException e) {
20177       {
20178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20179       };
20180     } catch (...) {
20181       {
20182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20183       };
20184     }
20185   }
20186
20187   jresult = result;
20188   return jresult;
20189 }
20190
20191
20192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20193   void * jresult ;
20194   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20195   Dali::PropertyNotifySignalType *result = 0 ;
20196
20197   arg1 = (Dali::PropertyNotification *)jarg1;
20198   {
20199     try {
20200       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20201     } catch (std::out_of_range& e) {
20202       {
20203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20204       };
20205     } catch (std::exception& e) {
20206       {
20207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20208       };
20209     } catch (Dali::DaliException e) {
20210       {
20211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20212       };
20213     } catch (...) {
20214       {
20215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20216       };
20217     }
20218   }
20219
20220   jresult = (void *)result;
20221   return jresult;
20222 }
20223
20224
20225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20226   void * jresult ;
20227   Dali::Handle *result = 0 ;
20228
20229   {
20230     try {
20231       result = (Dali::Handle *)new Dali::Handle();
20232     } catch (std::out_of_range& e) {
20233       {
20234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20235       };
20236     } catch (std::exception& e) {
20237       {
20238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20239       };
20240     } catch (Dali::DaliException e) {
20241       {
20242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20243       };
20244     } catch (...) {
20245       {
20246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20247       };
20248     }
20249   }
20250
20251   jresult = (void *)result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20257   void * jresult ;
20258   Dali::Handle result;
20259
20260   {
20261     try {
20262       result = Dali::Handle::New();
20263     } catch (std::out_of_range& e) {
20264       {
20265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20266       };
20267     } catch (std::exception& e) {
20268       {
20269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20270       };
20271     } catch (Dali::DaliException e) {
20272       {
20273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20274       };
20275     } catch (...) {
20276       {
20277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20278       };
20279     }
20280   }
20281
20282   jresult = new Dali::Handle((const Dali::Handle &)result);
20283   return jresult;
20284 }
20285
20286
20287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20288   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20289
20290   arg1 = (Dali::Handle *)jarg1;
20291   {
20292     try {
20293       delete arg1;
20294     } catch (std::out_of_range& e) {
20295       {
20296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20297       };
20298     } catch (std::exception& e) {
20299       {
20300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20301       };
20302     } catch (Dali::DaliException e) {
20303       {
20304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20305       };
20306     } catch (...) {
20307       {
20308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20309       };
20310     }
20311   }
20312
20313 }
20314
20315
20316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20317   void * jresult ;
20318   Dali::Handle *arg1 = 0 ;
20319   Dali::Handle *result = 0 ;
20320
20321   arg1 = (Dali::Handle *)jarg1;
20322   if (!arg1) {
20323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20324     return 0;
20325   }
20326   {
20327     try {
20328       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20329     } catch (std::out_of_range& e) {
20330       {
20331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20332       };
20333     } catch (std::exception& e) {
20334       {
20335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20336       };
20337     } catch (Dali::DaliException e) {
20338       {
20339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20340       };
20341     } catch (...) {
20342       {
20343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20344       };
20345     }
20346   }
20347
20348   jresult = (void *)result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20354   void * jresult ;
20355   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20356   Dali::Handle *arg2 = 0 ;
20357   Dali::Handle *result = 0 ;
20358
20359   arg1 = (Dali::Handle *)jarg1;
20360   arg2 = (Dali::Handle *)jarg2;
20361   if (!arg2) {
20362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20363     return 0;
20364   }
20365   {
20366     try {
20367       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20368     } catch (std::out_of_range& e) {
20369       {
20370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20371       };
20372     } catch (std::exception& e) {
20373       {
20374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20375       };
20376     } catch (Dali::DaliException e) {
20377       {
20378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20379       };
20380     } catch (...) {
20381       {
20382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20383       };
20384     }
20385   }
20386
20387   jresult = (void *)result;
20388   return jresult;
20389 }
20390
20391
20392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20393   void * jresult ;
20394   Dali::BaseHandle arg1 ;
20395   Dali::BaseHandle *argp1 ;
20396   Dali::Handle result;
20397
20398   argp1 = (Dali::BaseHandle *)jarg1;
20399   if (!argp1) {
20400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20401     return 0;
20402   }
20403   arg1 = *argp1;
20404   {
20405     try {
20406       result = Dali::Handle::DownCast(arg1);
20407     } catch (std::out_of_range& e) {
20408       {
20409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20410       };
20411     } catch (std::exception& e) {
20412       {
20413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20414       };
20415     } catch (Dali::DaliException e) {
20416       {
20417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20418       };
20419     } catch (...) {
20420       {
20421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20422       };
20423     }
20424   }
20425
20426   jresult = new Dali::Handle((const Dali::Handle &)result);
20427   return jresult;
20428 }
20429
20430
20431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20432   unsigned int jresult ;
20433   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20434   Dali::Handle::Capability arg2 ;
20435   bool result;
20436
20437   arg1 = (Dali::Handle *)jarg1;
20438   arg2 = (Dali::Handle::Capability)jarg2;
20439   {
20440     try {
20441       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20442     } catch (std::out_of_range& e) {
20443       {
20444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20445       };
20446     } catch (std::exception& e) {
20447       {
20448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20449       };
20450     } catch (Dali::DaliException e) {
20451       {
20452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20453       };
20454     } catch (...) {
20455       {
20456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20457       };
20458     }
20459   }
20460
20461   jresult = result;
20462   return jresult;
20463 }
20464
20465
20466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20467   unsigned int jresult ;
20468   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20469   unsigned int result;
20470
20471   arg1 = (Dali::Handle *)jarg1;
20472   {
20473     try {
20474       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20475     } catch (std::out_of_range& e) {
20476       {
20477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20478       };
20479     } catch (std::exception& e) {
20480       {
20481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20482       };
20483     } catch (Dali::DaliException e) {
20484       {
20485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20486       };
20487     } catch (...) {
20488       {
20489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20490       };
20491     }
20492   }
20493
20494   jresult = result;
20495   return jresult;
20496 }
20497
20498
20499 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20500   char * jresult ;
20501   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20502   Dali::Property::Index arg2 ;
20503   std::string result;
20504
20505   arg1 = (Dali::Handle *)jarg1;
20506   arg2 = (Dali::Property::Index)jarg2;
20507   {
20508     try {
20509       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20510     } catch (std::out_of_range& e) {
20511       {
20512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20513       };
20514     } catch (std::exception& e) {
20515       {
20516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20517       };
20518     } catch (Dali::DaliException e) {
20519       {
20520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20521       };
20522     } catch (...) {
20523       {
20524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20525       };
20526     }
20527   }
20528
20529   jresult = SWIG_csharp_string_callback((&result)->c_str());
20530   return jresult;
20531 }
20532
20533
20534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20535   int jresult ;
20536   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20537   std::string *arg2 = 0 ;
20538   Dali::Property::Index result;
20539
20540   arg1 = (Dali::Handle *)jarg1;
20541   if (!jarg2) {
20542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20543     return 0;
20544   }
20545   std::string arg2_str(jarg2);
20546   arg2 = &arg2_str;
20547   {
20548     try {
20549       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20550     } catch (std::out_of_range& e) {
20551       {
20552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20553       };
20554     } catch (std::exception& e) {
20555       {
20556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20557       };
20558     } catch (Dali::DaliException e) {
20559       {
20560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20561       };
20562     } catch (...) {
20563       {
20564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20565       };
20566     }
20567   }
20568
20569   jresult = result;
20570
20571   //argout typemap for const std::string&
20572
20573   return jresult;
20574 }
20575
20576
20577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20578   unsigned int jresult ;
20579   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20580   Dali::Property::Index arg2 ;
20581   bool result;
20582
20583   arg1 = (Dali::Handle *)jarg1;
20584   arg2 = (Dali::Property::Index)jarg2;
20585   {
20586     try {
20587       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20588     } catch (std::out_of_range& e) {
20589       {
20590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20591       };
20592     } catch (std::exception& e) {
20593       {
20594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20595       };
20596     } catch (Dali::DaliException e) {
20597       {
20598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20599       };
20600     } catch (...) {
20601       {
20602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20603       };
20604     }
20605   }
20606
20607   jresult = result;
20608   return jresult;
20609 }
20610
20611
20612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20613   unsigned int jresult ;
20614   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20615   Dali::Property::Index arg2 ;
20616   bool result;
20617
20618   arg1 = (Dali::Handle *)jarg1;
20619   arg2 = (Dali::Property::Index)jarg2;
20620   {
20621     try {
20622       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20623     } catch (std::out_of_range& e) {
20624       {
20625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20626       };
20627     } catch (std::exception& e) {
20628       {
20629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20630       };
20631     } catch (Dali::DaliException e) {
20632       {
20633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20634       };
20635     } catch (...) {
20636       {
20637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20638       };
20639     }
20640   }
20641
20642   jresult = result;
20643   return jresult;
20644 }
20645
20646
20647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20648   unsigned int jresult ;
20649   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20650   Dali::Property::Index arg2 ;
20651   bool result;
20652
20653   arg1 = (Dali::Handle *)jarg1;
20654   arg2 = (Dali::Property::Index)jarg2;
20655   {
20656     try {
20657       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20658     } catch (std::out_of_range& e) {
20659       {
20660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20661       };
20662     } catch (std::exception& e) {
20663       {
20664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20665       };
20666     } catch (Dali::DaliException e) {
20667       {
20668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20669       };
20670     } catch (...) {
20671       {
20672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20673       };
20674     }
20675   }
20676
20677   jresult = result;
20678   return jresult;
20679 }
20680
20681
20682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20683   int jresult ;
20684   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20685   Dali::Property::Index arg2 ;
20686   Dali::Property::Type result;
20687
20688   arg1 = (Dali::Handle *)jarg1;
20689   arg2 = (Dali::Property::Index)jarg2;
20690   {
20691     try {
20692       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20693     } catch (std::out_of_range& e) {
20694       {
20695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20696       };
20697     } catch (std::exception& e) {
20698       {
20699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (Dali::DaliException e) {
20702       {
20703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20704       };
20705     } catch (...) {
20706       {
20707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20708       };
20709     }
20710   }
20711
20712   jresult = (int)result;
20713   return jresult;
20714 }
20715
20716
20717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20718   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20719   Dali::Property::Index arg2 ;
20720   Dali::Property::Value *arg3 = 0 ;
20721
20722   arg1 = (Dali::Handle *)jarg1;
20723   arg2 = (Dali::Property::Index)jarg2;
20724   arg3 = (Dali::Property::Value *)jarg3;
20725   if (!arg3) {
20726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20727     return ;
20728   }
20729   {
20730     try {
20731       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20732     } catch (std::out_of_range& e) {
20733       {
20734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20735       };
20736     } catch (std::exception& e) {
20737       {
20738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20739       };
20740     } catch (Dali::DaliException e) {
20741       {
20742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20743       };
20744     } catch (...) {
20745       {
20746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20747       };
20748     }
20749   }
20750
20751 }
20752
20753
20754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20755   int jresult ;
20756   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20757   std::string *arg2 = 0 ;
20758   Dali::Property::Value *arg3 = 0 ;
20759   Dali::Property::Index result;
20760
20761   arg1 = (Dali::Handle *)jarg1;
20762   if (!jarg2) {
20763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20764     return 0;
20765   }
20766   std::string arg2_str(jarg2);
20767   arg2 = &arg2_str;
20768   arg3 = (Dali::Property::Value *)jarg3;
20769   if (!arg3) {
20770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20771     return 0;
20772   }
20773   {
20774     try {
20775       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20776     } catch (std::out_of_range& e) {
20777       {
20778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20779       };
20780     } catch (std::exception& e) {
20781       {
20782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20783       };
20784     } catch (Dali::DaliException e) {
20785       {
20786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20787       };
20788     } catch (...) {
20789       {
20790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20791       };
20792     }
20793   }
20794
20795   jresult = result;
20796
20797   //argout typemap for const std::string&
20798
20799   return jresult;
20800 }
20801
20802
20803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20804   int jresult ;
20805   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20806   std::string *arg2 = 0 ;
20807   Dali::Property::Value *arg3 = 0 ;
20808   Dali::Property::AccessMode arg4 ;
20809   Dali::Property::Index result;
20810
20811   arg1 = (Dali::Handle *)jarg1;
20812   if (!jarg2) {
20813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20814     return 0;
20815   }
20816   std::string arg2_str(jarg2);
20817   arg2 = &arg2_str;
20818   arg3 = (Dali::Property::Value *)jarg3;
20819   if (!arg3) {
20820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20821     return 0;
20822   }
20823   arg4 = (Dali::Property::AccessMode)jarg4;
20824   {
20825     try {
20826       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20827     } catch (std::out_of_range& e) {
20828       {
20829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20830       };
20831     } catch (std::exception& e) {
20832       {
20833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20834       };
20835     } catch (Dali::DaliException e) {
20836       {
20837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20838       };
20839     } catch (...) {
20840       {
20841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20842       };
20843     }
20844   }
20845
20846   jresult = result;
20847
20848   //argout typemap for const std::string&
20849
20850   return jresult;
20851 }
20852
20853
20854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20855   void * jresult ;
20856   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20857   Dali::Property::Index arg2 ;
20858   Dali::Property::Value result;
20859
20860   arg1 = (Dali::Handle *)jarg1;
20861   arg2 = (Dali::Property::Index)jarg2;
20862   {
20863     try {
20864       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20865     } catch (std::out_of_range& e) {
20866       {
20867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20868       };
20869     } catch (std::exception& e) {
20870       {
20871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20872       };
20873     } catch (Dali::DaliException e) {
20874       {
20875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20876       };
20877     } catch (...) {
20878       {
20879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20880       };
20881     }
20882   }
20883
20884   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20885   return jresult;
20886 }
20887
20888
20889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20890   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20891   Dali::Property::IndexContainer *arg2 = 0 ;
20892
20893   arg1 = (Dali::Handle *)jarg1;
20894   arg2 = (Dali::Property::IndexContainer *)jarg2;
20895   if (!arg2) {
20896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20897     return ;
20898   }
20899   {
20900     try {
20901       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20902     } catch (std::out_of_range& e) {
20903       {
20904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20905       };
20906     } catch (std::exception& e) {
20907       {
20908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20909       };
20910     } catch (Dali::DaliException e) {
20911       {
20912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20913       };
20914     } catch (...) {
20915       {
20916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20917       };
20918     }
20919   }
20920
20921 }
20922
20923
20924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20925   void * jresult ;
20926   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20927   Dali::Property::Index arg2 ;
20928   Dali::PropertyCondition *arg3 = 0 ;
20929   Dali::PropertyNotification result;
20930
20931   arg1 = (Dali::Handle *)jarg1;
20932   arg2 = (Dali::Property::Index)jarg2;
20933   arg3 = (Dali::PropertyCondition *)jarg3;
20934   if (!arg3) {
20935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20936     return 0;
20937   }
20938   {
20939     try {
20940       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20941     } catch (std::out_of_range& e) {
20942       {
20943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20944       };
20945     } catch (std::exception& e) {
20946       {
20947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20948       };
20949     } catch (Dali::DaliException e) {
20950       {
20951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20952       };
20953     } catch (...) {
20954       {
20955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20956       };
20957     }
20958   }
20959
20960   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20961   return jresult;
20962 }
20963
20964
20965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20966   void * jresult ;
20967   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20968   Dali::Property::Index arg2 ;
20969   int arg3 ;
20970   Dali::PropertyCondition *arg4 = 0 ;
20971   Dali::PropertyNotification result;
20972
20973   arg1 = (Dali::Handle *)jarg1;
20974   arg2 = (Dali::Property::Index)jarg2;
20975   arg3 = (int)jarg3;
20976   arg4 = (Dali::PropertyCondition *)jarg4;
20977   if (!arg4) {
20978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20979     return 0;
20980   }
20981   {
20982     try {
20983       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20984     } catch (std::out_of_range& e) {
20985       {
20986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20987       };
20988     } catch (std::exception& e) {
20989       {
20990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20991       };
20992     } catch (Dali::DaliException e) {
20993       {
20994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20995       };
20996     } catch (...) {
20997       {
20998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20999       };
21000     }
21001   }
21002
21003   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21004   return jresult;
21005 }
21006
21007
21008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21009   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21010   Dali::PropertyNotification arg2 ;
21011   Dali::PropertyNotification *argp2 ;
21012
21013   arg1 = (Dali::Handle *)jarg1;
21014   argp2 = (Dali::PropertyNotification *)jarg2;
21015   if (!argp2) {
21016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21017     return ;
21018   }
21019   arg2 = *argp2;
21020   {
21021     try {
21022       (arg1)->RemovePropertyNotification(arg2);
21023     } catch (std::out_of_range& e) {
21024       {
21025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21026       };
21027     } catch (std::exception& e) {
21028       {
21029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21030       };
21031     } catch (Dali::DaliException e) {
21032       {
21033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21034       };
21035     } catch (...) {
21036       {
21037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21038       };
21039     }
21040   }
21041
21042 }
21043
21044
21045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21046   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21047
21048   arg1 = (Dali::Handle *)jarg1;
21049   {
21050     try {
21051       (arg1)->RemovePropertyNotifications();
21052     } catch (std::out_of_range& e) {
21053       {
21054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21055       };
21056     } catch (std::exception& e) {
21057       {
21058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21059       };
21060     } catch (Dali::DaliException e) {
21061       {
21062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21063       };
21064     } catch (...) {
21065       {
21066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21067       };
21068     }
21069   }
21070
21071 }
21072
21073
21074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21075   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21076
21077   arg1 = (Dali::Handle *)jarg1;
21078   {
21079     try {
21080       (arg1)->RemoveConstraints();
21081     } catch (std::out_of_range& e) {
21082       {
21083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21084       };
21085     } catch (std::exception& e) {
21086       {
21087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21088       };
21089     } catch (Dali::DaliException e) {
21090       {
21091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21092       };
21093     } catch (...) {
21094       {
21095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21096       };
21097     }
21098   }
21099
21100 }
21101
21102
21103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21104   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21105   unsigned int arg2 ;
21106
21107   arg1 = (Dali::Handle *)jarg1;
21108   arg2 = (unsigned int)jarg2;
21109   {
21110     try {
21111       (arg1)->RemoveConstraints(arg2);
21112     } catch (std::out_of_range& e) {
21113       {
21114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21115       };
21116     } catch (std::exception& e) {
21117       {
21118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21119       };
21120     } catch (Dali::DaliException e) {
21121       {
21122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21123       };
21124     } catch (...) {
21125       {
21126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21127       };
21128     }
21129   }
21130
21131 }
21132
21133
21134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21135   int jresult ;
21136   Dali::Property::Index result;
21137
21138   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21139   jresult = result;
21140   return jresult;
21141 }
21142
21143
21144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21145   void * jresult ;
21146   Dali::Handle result;
21147
21148   {
21149     try {
21150       result = Dali::WeightObject::New();
21151     } catch (std::out_of_range& e) {
21152       {
21153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21154       };
21155     } catch (std::exception& e) {
21156       {
21157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21158       };
21159     } catch (Dali::DaliException e) {
21160       {
21161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21162       };
21163     } catch (...) {
21164       {
21165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21166       };
21167     }
21168   }
21169
21170   jresult = new Dali::Handle((const Dali::Handle &)result);
21171   return jresult;
21172 }
21173
21174
21175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21176   void * jresult ;
21177   Dali::TypeInfo *result = 0 ;
21178
21179   {
21180     try {
21181       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21182     } catch (std::out_of_range& e) {
21183       {
21184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21185       };
21186     } catch (std::exception& e) {
21187       {
21188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21189       };
21190     } catch (Dali::DaliException e) {
21191       {
21192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21193       };
21194     } catch (...) {
21195       {
21196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21197       };
21198     }
21199   }
21200
21201   jresult = (void *)result;
21202   return jresult;
21203 }
21204
21205
21206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21207   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21208
21209   arg1 = (Dali::TypeInfo *)jarg1;
21210   {
21211     try {
21212       delete arg1;
21213     } catch (std::out_of_range& e) {
21214       {
21215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21216       };
21217     } catch (std::exception& e) {
21218       {
21219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21220       };
21221     } catch (Dali::DaliException e) {
21222       {
21223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21224       };
21225     } catch (...) {
21226       {
21227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21228       };
21229     }
21230   }
21231
21232 }
21233
21234
21235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21236   void * jresult ;
21237   Dali::TypeInfo *arg1 = 0 ;
21238   Dali::TypeInfo *result = 0 ;
21239
21240   arg1 = (Dali::TypeInfo *)jarg1;
21241   if (!arg1) {
21242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21243     return 0;
21244   }
21245   {
21246     try {
21247       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21248     } catch (std::out_of_range& e) {
21249       {
21250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21251       };
21252     } catch (std::exception& e) {
21253       {
21254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21255       };
21256     } catch (Dali::DaliException e) {
21257       {
21258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21259       };
21260     } catch (...) {
21261       {
21262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21263       };
21264     }
21265   }
21266
21267   jresult = (void *)result;
21268   return jresult;
21269 }
21270
21271
21272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21273   void * jresult ;
21274   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21275   Dali::TypeInfo *arg2 = 0 ;
21276   Dali::TypeInfo *result = 0 ;
21277
21278   arg1 = (Dali::TypeInfo *)jarg1;
21279   arg2 = (Dali::TypeInfo *)jarg2;
21280   if (!arg2) {
21281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21282     return 0;
21283   }
21284   {
21285     try {
21286       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21287     } catch (std::out_of_range& e) {
21288       {
21289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21290       };
21291     } catch (std::exception& e) {
21292       {
21293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21294       };
21295     } catch (Dali::DaliException e) {
21296       {
21297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21298       };
21299     } catch (...) {
21300       {
21301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21302       };
21303     }
21304   }
21305
21306   jresult = (void *)result;
21307   return jresult;
21308 }
21309
21310
21311 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21312   char * jresult ;
21313   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21314   std::string *result = 0 ;
21315
21316   arg1 = (Dali::TypeInfo *)jarg1;
21317   {
21318     try {
21319       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21320     } catch (std::out_of_range& e) {
21321       {
21322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21323       };
21324     } catch (std::exception& e) {
21325       {
21326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21327       };
21328     } catch (Dali::DaliException e) {
21329       {
21330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21331       };
21332     } catch (...) {
21333       {
21334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21335       };
21336     }
21337   }
21338
21339   jresult = SWIG_csharp_string_callback(result->c_str());
21340   return jresult;
21341 }
21342
21343
21344 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21345   char * jresult ;
21346   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21347   std::string *result = 0 ;
21348
21349   arg1 = (Dali::TypeInfo *)jarg1;
21350   {
21351     try {
21352       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21353     } catch (std::out_of_range& e) {
21354       {
21355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21356       };
21357     } catch (std::exception& e) {
21358       {
21359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21360       };
21361     } catch (Dali::DaliException e) {
21362       {
21363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21364       };
21365     } catch (...) {
21366       {
21367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21368       };
21369     }
21370   }
21371
21372   jresult = SWIG_csharp_string_callback(result->c_str());
21373   return jresult;
21374 }
21375
21376
21377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21378   void * jresult ;
21379   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21380   Dali::BaseHandle result;
21381
21382   arg1 = (Dali::TypeInfo *)jarg1;
21383   {
21384     try {
21385       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21386     } catch (std::out_of_range& e) {
21387       {
21388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21389       };
21390     } catch (std::exception& e) {
21391       {
21392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21393       };
21394     } catch (Dali::DaliException e) {
21395       {
21396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21397       };
21398     } catch (...) {
21399       {
21400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21401       };
21402     }
21403   }
21404
21405   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21406   return jresult;
21407 }
21408
21409
21410 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21411   unsigned long jresult ;
21412   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21413   size_t result;
21414
21415   arg1 = (Dali::TypeInfo *)jarg1;
21416   {
21417     try {
21418       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21419     } catch (std::out_of_range& e) {
21420       {
21421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21422       };
21423     } catch (std::exception& e) {
21424       {
21425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21426       };
21427     } catch (Dali::DaliException e) {
21428       {
21429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21430       };
21431     } catch (...) {
21432       {
21433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21434       };
21435     }
21436   }
21437
21438   jresult = (unsigned long)result;
21439   return jresult;
21440 }
21441
21442
21443 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21444   char * jresult ;
21445   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21446   size_t arg2 ;
21447   std::string result;
21448
21449   arg1 = (Dali::TypeInfo *)jarg1;
21450   arg2 = (size_t)jarg2;
21451   {
21452     try {
21453       result = (arg1)->GetActionName(arg2);
21454     } catch (std::out_of_range& e) {
21455       {
21456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21457       };
21458     } catch (std::exception& e) {
21459       {
21460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21461       };
21462     } catch (Dali::DaliException e) {
21463       {
21464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21465       };
21466     } catch (...) {
21467       {
21468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21469       };
21470     }
21471   }
21472
21473   jresult = SWIG_csharp_string_callback((&result)->c_str());
21474   return jresult;
21475 }
21476
21477
21478 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21479   unsigned long jresult ;
21480   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21481   size_t result;
21482
21483   arg1 = (Dali::TypeInfo *)jarg1;
21484   {
21485     try {
21486       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21487     } catch (std::out_of_range& e) {
21488       {
21489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21490       };
21491     } catch (std::exception& e) {
21492       {
21493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21494       };
21495     } catch (Dali::DaliException e) {
21496       {
21497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21498       };
21499     } catch (...) {
21500       {
21501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21502       };
21503     }
21504   }
21505
21506   jresult = (unsigned long)result;
21507   return jresult;
21508 }
21509
21510
21511 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21512   char * jresult ;
21513   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21514   size_t arg2 ;
21515   std::string result;
21516
21517   arg1 = (Dali::TypeInfo *)jarg1;
21518   arg2 = (size_t)jarg2;
21519   {
21520     try {
21521       result = (arg1)->GetSignalName(arg2);
21522     } catch (std::out_of_range& e) {
21523       {
21524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21525       };
21526     } catch (std::exception& e) {
21527       {
21528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21529       };
21530     } catch (Dali::DaliException e) {
21531       {
21532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21533       };
21534     } catch (...) {
21535       {
21536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21537       };
21538     }
21539   }
21540
21541   jresult = SWIG_csharp_string_callback((&result)->c_str());
21542   return jresult;
21543 }
21544
21545
21546 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21547   unsigned long jresult ;
21548   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21549   size_t result;
21550
21551   arg1 = (Dali::TypeInfo *)jarg1;
21552   {
21553     try {
21554       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21555     } catch (std::out_of_range& e) {
21556       {
21557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21558       };
21559     } catch (std::exception& e) {
21560       {
21561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21562       };
21563     } catch (Dali::DaliException e) {
21564       {
21565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21566       };
21567     } catch (...) {
21568       {
21569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21570       };
21571     }
21572   }
21573
21574   jresult = (unsigned long)result;
21575   return jresult;
21576 }
21577
21578
21579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21580   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21581   Dali::Property::IndexContainer *arg2 = 0 ;
21582
21583   arg1 = (Dali::TypeInfo *)jarg1;
21584   arg2 = (Dali::Property::IndexContainer *)jarg2;
21585   if (!arg2) {
21586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21587     return ;
21588   }
21589   {
21590     try {
21591       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21592     } catch (std::out_of_range& e) {
21593       {
21594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21595       };
21596     } catch (std::exception& e) {
21597       {
21598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21599       };
21600     } catch (Dali::DaliException e) {
21601       {
21602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21603       };
21604     } catch (...) {
21605       {
21606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21607       };
21608     }
21609   }
21610
21611 }
21612
21613
21614 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21615   char * jresult ;
21616   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21617   Dali::Property::Index arg2 ;
21618   std::string *result = 0 ;
21619
21620   arg1 = (Dali::TypeInfo *)jarg1;
21621   arg2 = (Dali::Property::Index)jarg2;
21622   {
21623     try {
21624       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21625     } catch (std::out_of_range& e) {
21626       {
21627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21628       };
21629     } catch (std::exception& e) {
21630       {
21631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21632       };
21633     } catch (Dali::DaliException e) {
21634       {
21635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21636       };
21637     } catch (...) {
21638       {
21639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21640       };
21641     }
21642   }
21643
21644   jresult = SWIG_csharp_string_callback(result->c_str());
21645   return jresult;
21646 }
21647
21648
21649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21650   void * jresult ;
21651   Dali::TypeRegistry result;
21652
21653   {
21654     try {
21655       result = Dali::TypeRegistry::Get();
21656     } catch (std::out_of_range& e) {
21657       {
21658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21659       };
21660     } catch (std::exception& e) {
21661       {
21662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21663       };
21664     } catch (Dali::DaliException e) {
21665       {
21666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21667       };
21668     } catch (...) {
21669       {
21670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21671       };
21672     }
21673   }
21674
21675   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21676   return jresult;
21677 }
21678
21679
21680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21681   void * jresult ;
21682   Dali::TypeRegistry *result = 0 ;
21683
21684   {
21685     try {
21686       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21687     } catch (std::out_of_range& e) {
21688       {
21689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21690       };
21691     } catch (std::exception& e) {
21692       {
21693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21694       };
21695     } catch (Dali::DaliException e) {
21696       {
21697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21698       };
21699     } catch (...) {
21700       {
21701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21702       };
21703     }
21704   }
21705
21706   jresult = (void *)result;
21707   return jresult;
21708 }
21709
21710
21711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21712   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21713
21714   arg1 = (Dali::TypeRegistry *)jarg1;
21715   {
21716     try {
21717       delete arg1;
21718     } catch (std::out_of_range& e) {
21719       {
21720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21721       };
21722     } catch (std::exception& e) {
21723       {
21724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21725       };
21726     } catch (Dali::DaliException e) {
21727       {
21728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21729       };
21730     } catch (...) {
21731       {
21732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21733       };
21734     }
21735   }
21736
21737 }
21738
21739
21740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21741   void * jresult ;
21742   Dali::TypeRegistry *arg1 = 0 ;
21743   Dali::TypeRegistry *result = 0 ;
21744
21745   arg1 = (Dali::TypeRegistry *)jarg1;
21746   if (!arg1) {
21747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21748     return 0;
21749   }
21750   {
21751     try {
21752       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21753     } catch (std::out_of_range& e) {
21754       {
21755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21756       };
21757     } catch (std::exception& e) {
21758       {
21759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21760       };
21761     } catch (Dali::DaliException e) {
21762       {
21763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21764       };
21765     } catch (...) {
21766       {
21767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21768       };
21769     }
21770   }
21771
21772   jresult = (void *)result;
21773   return jresult;
21774 }
21775
21776
21777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21778   void * jresult ;
21779   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21780   Dali::TypeRegistry *arg2 = 0 ;
21781   Dali::TypeRegistry *result = 0 ;
21782
21783   arg1 = (Dali::TypeRegistry *)jarg1;
21784   arg2 = (Dali::TypeRegistry *)jarg2;
21785   if (!arg2) {
21786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21787     return 0;
21788   }
21789   {
21790     try {
21791       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21792     } catch (std::out_of_range& e) {
21793       {
21794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21795       };
21796     } catch (std::exception& e) {
21797       {
21798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21799       };
21800     } catch (Dali::DaliException e) {
21801       {
21802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21803       };
21804     } catch (...) {
21805       {
21806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21807       };
21808     }
21809   }
21810
21811   jresult = (void *)result;
21812   return jresult;
21813 }
21814
21815
21816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21817   void * jresult ;
21818   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21819   std::string *arg2 = 0 ;
21820   Dali::TypeInfo result;
21821
21822   arg1 = (Dali::TypeRegistry *)jarg1;
21823   if (!jarg2) {
21824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21825     return 0;
21826   }
21827   std::string arg2_str(jarg2);
21828   arg2 = &arg2_str;
21829   {
21830     try {
21831       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21832     } catch (std::out_of_range& e) {
21833       {
21834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21835       };
21836     } catch (std::exception& e) {
21837       {
21838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21839       };
21840     } catch (Dali::DaliException e) {
21841       {
21842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21843       };
21844     } catch (...) {
21845       {
21846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21847       };
21848     }
21849   }
21850
21851   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21852
21853   //argout typemap for const std::string&
21854
21855   return jresult;
21856 }
21857
21858
21859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21860   void * jresult ;
21861   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21862   std::type_info *arg2 = 0 ;
21863   Dali::TypeInfo result;
21864
21865   arg1 = (Dali::TypeRegistry *)jarg1;
21866   arg2 = (std::type_info *)jarg2;
21867   if (!arg2) {
21868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21869     return 0;
21870   }
21871   {
21872     try {
21873       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21874     } catch (std::out_of_range& e) {
21875       {
21876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21877       };
21878     } catch (std::exception& e) {
21879       {
21880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21881       };
21882     } catch (Dali::DaliException e) {
21883       {
21884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21885       };
21886     } catch (...) {
21887       {
21888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21889       };
21890     }
21891   }
21892
21893   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21894   return jresult;
21895 }
21896
21897
21898 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21899   unsigned long jresult ;
21900   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21901   size_t result;
21902
21903   arg1 = (Dali::TypeRegistry *)jarg1;
21904   {
21905     try {
21906       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21907     } catch (std::out_of_range& e) {
21908       {
21909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21910       };
21911     } catch (std::exception& e) {
21912       {
21913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21914       };
21915     } catch (Dali::DaliException e) {
21916       {
21917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21918       };
21919     } catch (...) {
21920       {
21921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21922       };
21923     }
21924   }
21925
21926   jresult = (unsigned long)result;
21927   return jresult;
21928 }
21929
21930
21931 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21932   char * jresult ;
21933   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21934   size_t arg2 ;
21935   std::string result;
21936
21937   arg1 = (Dali::TypeRegistry *)jarg1;
21938   arg2 = (size_t)jarg2;
21939   {
21940     try {
21941       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21942     } catch (std::out_of_range& e) {
21943       {
21944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21945       };
21946     } catch (std::exception& e) {
21947       {
21948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21949       };
21950     } catch (Dali::DaliException e) {
21951       {
21952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21953       };
21954     } catch (...) {
21955       {
21956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21957       };
21958     }
21959   }
21960
21961   jresult = SWIG_csharp_string_callback((&result)->c_str());
21962   return jresult;
21963 }
21964
21965
21966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21967   void * jresult ;
21968   std::type_info *arg1 = 0 ;
21969   std::type_info *arg2 = 0 ;
21970   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21971   Dali::TypeRegistration *result = 0 ;
21972
21973   arg1 = (std::type_info *)jarg1;
21974   if (!arg1) {
21975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21976     return 0;
21977   }
21978   arg2 = (std::type_info *)jarg2;
21979   if (!arg2) {
21980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21981     return 0;
21982   }
21983   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21984   {
21985     try {
21986       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21987     } catch (std::out_of_range& e) {
21988       {
21989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21990       };
21991     } catch (std::exception& e) {
21992       {
21993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21994       };
21995     } catch (Dali::DaliException e) {
21996       {
21997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21998       };
21999     } catch (...) {
22000       {
22001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22002       };
22003     }
22004   }
22005
22006   jresult = (void *)result;
22007   return jresult;
22008 }
22009
22010
22011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22012   void * jresult ;
22013   std::type_info *arg1 = 0 ;
22014   std::type_info *arg2 = 0 ;
22015   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22016   bool arg4 ;
22017   Dali::TypeRegistration *result = 0 ;
22018
22019   arg1 = (std::type_info *)jarg1;
22020   if (!arg1) {
22021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22022     return 0;
22023   }
22024   arg2 = (std::type_info *)jarg2;
22025   if (!arg2) {
22026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22027     return 0;
22028   }
22029   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22030   arg4 = jarg4 ? true : false;
22031   {
22032     try {
22033       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22034     } catch (std::out_of_range& e) {
22035       {
22036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22037       };
22038     } catch (std::exception& e) {
22039       {
22040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22041       };
22042     } catch (Dali::DaliException e) {
22043       {
22044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22045       };
22046     } catch (...) {
22047       {
22048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22049       };
22050     }
22051   }
22052
22053   jresult = (void *)result;
22054   return jresult;
22055 }
22056
22057
22058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22059   void * jresult ;
22060   std::string *arg1 = 0 ;
22061   std::type_info *arg2 = 0 ;
22062   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22063   Dali::TypeRegistration *result = 0 ;
22064
22065   if (!jarg1) {
22066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22067     return 0;
22068   }
22069   std::string arg1_str(jarg1);
22070   arg1 = &arg1_str;
22071   arg2 = (std::type_info *)jarg2;
22072   if (!arg2) {
22073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22074     return 0;
22075   }
22076   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22077   {
22078     try {
22079       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22080     } catch (std::out_of_range& e) {
22081       {
22082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22083       };
22084     } catch (std::exception& e) {
22085       {
22086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22087       };
22088     } catch (Dali::DaliException e) {
22089       {
22090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22091       };
22092     } catch (...) {
22093       {
22094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22095       };
22096     }
22097   }
22098
22099   jresult = (void *)result;
22100
22101   //argout typemap for const std::string&
22102
22103   return jresult;
22104 }
22105
22106
22107 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22108   char * jresult ;
22109   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22110   std::string result;
22111
22112   arg1 = (Dali::TypeRegistration *)jarg1;
22113   {
22114     try {
22115       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22116     } catch (std::out_of_range& e) {
22117       {
22118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22119       };
22120     } catch (std::exception& e) {
22121       {
22122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22123       };
22124     } catch (Dali::DaliException e) {
22125       {
22126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22127       };
22128     } catch (...) {
22129       {
22130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22131       };
22132     }
22133   }
22134
22135   jresult = SWIG_csharp_string_callback((&result)->c_str());
22136   return jresult;
22137 }
22138
22139
22140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22141   std::string *arg1 = 0 ;
22142   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22143
22144   if (!jarg1) {
22145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22146     return ;
22147   }
22148   std::string arg1_str(jarg1);
22149   arg1 = &arg1_str;
22150   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22151   {
22152     try {
22153       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22154     } catch (std::out_of_range& e) {
22155       {
22156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22157       };
22158     } catch (std::exception& e) {
22159       {
22160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22161       };
22162     } catch (Dali::DaliException e) {
22163       {
22164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22165       };
22166     } catch (...) {
22167       {
22168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22169       };
22170     }
22171   }
22172
22173
22174   //argout typemap for const std::string&
22175
22176 }
22177
22178
22179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22180   std::string *arg1 = 0 ;
22181   std::string *arg2 = 0 ;
22182   int arg3 ;
22183   Dali::Property::Type arg4 ;
22184   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22185   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22186
22187   if (!jarg1) {
22188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22189     return ;
22190   }
22191   std::string arg1_str(jarg1);
22192   arg1 = &arg1_str;
22193   if (!jarg2) {
22194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22195     return ;
22196   }
22197   std::string arg2_str(jarg2);
22198   arg2 = &arg2_str;
22199   arg3 = (int)jarg3;
22200   arg4 = (Dali::Property::Type)jarg4;
22201   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22202   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22203   {
22204     try {
22205       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22206     } catch (std::out_of_range& e) {
22207       {
22208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22209       };
22210     } catch (std::exception& e) {
22211       {
22212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22213       };
22214     } catch (Dali::DaliException e) {
22215       {
22216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22217       };
22218     } catch (...) {
22219       {
22220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22221       };
22222     }
22223   }
22224
22225
22226   //argout typemap for const std::string&
22227
22228
22229   //argout typemap for const std::string&
22230
22231 }
22232
22233
22234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22235   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22236
22237   arg1 = (Dali::TypeRegistration *)jarg1;
22238   {
22239     try {
22240       delete arg1;
22241     } catch (std::out_of_range& e) {
22242       {
22243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22244       };
22245     } catch (std::exception& e) {
22246       {
22247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22248       };
22249     } catch (Dali::DaliException e) {
22250       {
22251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22252       };
22253     } catch (...) {
22254       {
22255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22256       };
22257     }
22258   }
22259
22260 }
22261
22262
22263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22264   void * jresult ;
22265   Dali::TypeRegistration *arg1 = 0 ;
22266   std::string *arg2 = 0 ;
22267   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22268   Dali::SignalConnectorType *result = 0 ;
22269
22270   arg1 = (Dali::TypeRegistration *)jarg1;
22271   if (!arg1) {
22272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22273     return 0;
22274   }
22275   if (!jarg2) {
22276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22277     return 0;
22278   }
22279   std::string arg2_str(jarg2);
22280   arg2 = &arg2_str;
22281   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22282   {
22283     try {
22284       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22285     } catch (std::out_of_range& e) {
22286       {
22287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22288       };
22289     } catch (std::exception& e) {
22290       {
22291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22292       };
22293     } catch (Dali::DaliException e) {
22294       {
22295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22296       };
22297     } catch (...) {
22298       {
22299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22300       };
22301     }
22302   }
22303
22304   jresult = (void *)result;
22305
22306   //argout typemap for const std::string&
22307
22308   return jresult;
22309 }
22310
22311
22312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22313   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22314
22315   arg1 = (Dali::SignalConnectorType *)jarg1;
22316   {
22317     try {
22318       delete arg1;
22319     } catch (std::out_of_range& e) {
22320       {
22321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22322       };
22323     } catch (std::exception& e) {
22324       {
22325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22326       };
22327     } catch (Dali::DaliException e) {
22328       {
22329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22330       };
22331     } catch (...) {
22332       {
22333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22334       };
22335     }
22336   }
22337
22338 }
22339
22340
22341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22342   void * jresult ;
22343   Dali::TypeRegistration *arg1 = 0 ;
22344   std::string *arg2 = 0 ;
22345   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22346   Dali::TypeAction *result = 0 ;
22347
22348   arg1 = (Dali::TypeRegistration *)jarg1;
22349   if (!arg1) {
22350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22351     return 0;
22352   }
22353   if (!jarg2) {
22354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22355     return 0;
22356   }
22357   std::string arg2_str(jarg2);
22358   arg2 = &arg2_str;
22359   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22360   {
22361     try {
22362       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22363     } catch (std::out_of_range& e) {
22364       {
22365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22366       };
22367     } catch (std::exception& e) {
22368       {
22369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22370       };
22371     } catch (Dali::DaliException e) {
22372       {
22373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22374       };
22375     } catch (...) {
22376       {
22377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22378       };
22379     }
22380   }
22381
22382   jresult = (void *)result;
22383
22384   //argout typemap for const std::string&
22385
22386   return jresult;
22387 }
22388
22389
22390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22391   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22392
22393   arg1 = (Dali::TypeAction *)jarg1;
22394   {
22395     try {
22396       delete arg1;
22397     } catch (std::out_of_range& e) {
22398       {
22399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22400       };
22401     } catch (std::exception& e) {
22402       {
22403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22404       };
22405     } catch (Dali::DaliException e) {
22406       {
22407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22408       };
22409     } catch (...) {
22410       {
22411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22412       };
22413     }
22414   }
22415
22416 }
22417
22418
22419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22420   void * jresult ;
22421   Dali::TypeRegistration *arg1 = 0 ;
22422   std::string *arg2 = 0 ;
22423   Dali::Property::Index arg3 ;
22424   Dali::Property::Type arg4 ;
22425   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22426   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22427   Dali::PropertyRegistration *result = 0 ;
22428
22429   arg1 = (Dali::TypeRegistration *)jarg1;
22430   if (!arg1) {
22431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22432     return 0;
22433   }
22434   if (!jarg2) {
22435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22436     return 0;
22437   }
22438   std::string arg2_str(jarg2);
22439   arg2 = &arg2_str;
22440   arg3 = (Dali::Property::Index)jarg3;
22441   arg4 = (Dali::Property::Type)jarg4;
22442   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22443   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22444   {
22445     try {
22446       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22447     } catch (std::out_of_range& e) {
22448       {
22449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22450       };
22451     } catch (std::exception& e) {
22452       {
22453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22454       };
22455     } catch (Dali::DaliException e) {
22456       {
22457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22458       };
22459     } catch (...) {
22460       {
22461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22462       };
22463     }
22464   }
22465
22466   jresult = (void *)result;
22467
22468   //argout typemap for const std::string&
22469
22470   return jresult;
22471 }
22472
22473
22474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22475   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22476
22477   arg1 = (Dali::PropertyRegistration *)jarg1;
22478   {
22479     try {
22480       delete arg1;
22481     } catch (std::out_of_range& e) {
22482       {
22483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22484       };
22485     } catch (std::exception& e) {
22486       {
22487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22488       };
22489     } catch (Dali::DaliException e) {
22490       {
22491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22492       };
22493     } catch (...) {
22494       {
22495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22496       };
22497     }
22498   }
22499
22500 }
22501
22502
22503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22504   void * jresult ;
22505   Dali::TypeRegistration *arg1 = 0 ;
22506   std::string *arg2 = 0 ;
22507   Dali::Property::Index arg3 ;
22508   Dali::Property::Type arg4 ;
22509   Dali::AnimatablePropertyRegistration *result = 0 ;
22510
22511   arg1 = (Dali::TypeRegistration *)jarg1;
22512   if (!arg1) {
22513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22514     return 0;
22515   }
22516   if (!jarg2) {
22517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22518     return 0;
22519   }
22520   std::string arg2_str(jarg2);
22521   arg2 = &arg2_str;
22522   arg3 = (Dali::Property::Index)jarg3;
22523   arg4 = (Dali::Property::Type)jarg4;
22524   {
22525     try {
22526       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22527     } catch (std::out_of_range& e) {
22528       {
22529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22530       };
22531     } catch (std::exception& e) {
22532       {
22533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22534       };
22535     } catch (Dali::DaliException e) {
22536       {
22537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22538       };
22539     } catch (...) {
22540       {
22541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22542       };
22543     }
22544   }
22545
22546   jresult = (void *)result;
22547
22548   //argout typemap for const std::string&
22549
22550   return jresult;
22551 }
22552
22553
22554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22555   void * jresult ;
22556   Dali::TypeRegistration *arg1 = 0 ;
22557   std::string *arg2 = 0 ;
22558   Dali::Property::Index arg3 ;
22559   Dali::Property::Value *arg4 = 0 ;
22560   Dali::AnimatablePropertyRegistration *result = 0 ;
22561
22562   arg1 = (Dali::TypeRegistration *)jarg1;
22563   if (!arg1) {
22564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22565     return 0;
22566   }
22567   if (!jarg2) {
22568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22569     return 0;
22570   }
22571   std::string arg2_str(jarg2);
22572   arg2 = &arg2_str;
22573   arg3 = (Dali::Property::Index)jarg3;
22574   arg4 = (Dali::Property::Value *)jarg4;
22575   if (!arg4) {
22576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22577     return 0;
22578   }
22579   {
22580     try {
22581       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22582     } catch (std::out_of_range& e) {
22583       {
22584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22585       };
22586     } catch (std::exception& e) {
22587       {
22588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22589       };
22590     } catch (Dali::DaliException e) {
22591       {
22592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22593       };
22594     } catch (...) {
22595       {
22596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22597       };
22598     }
22599   }
22600
22601   jresult = (void *)result;
22602
22603   //argout typemap for const std::string&
22604
22605   return jresult;
22606 }
22607
22608
22609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22610   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22611
22612   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22613   {
22614     try {
22615       delete arg1;
22616     } catch (std::out_of_range& e) {
22617       {
22618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22619       };
22620     } catch (std::exception& e) {
22621       {
22622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22623       };
22624     } catch (Dali::DaliException e) {
22625       {
22626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22627       };
22628     } catch (...) {
22629       {
22630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22631       };
22632     }
22633   }
22634
22635 }
22636
22637
22638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22639   void * jresult ;
22640   Dali::TypeRegistration *arg1 = 0 ;
22641   std::string *arg2 = 0 ;
22642   Dali::Property::Index arg3 ;
22643   Dali::Property::Index arg4 ;
22644   unsigned int arg5 ;
22645   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22646
22647   arg1 = (Dali::TypeRegistration *)jarg1;
22648   if (!arg1) {
22649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22650     return 0;
22651   }
22652   if (!jarg2) {
22653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22654     return 0;
22655   }
22656   std::string arg2_str(jarg2);
22657   arg2 = &arg2_str;
22658   arg3 = (Dali::Property::Index)jarg3;
22659   arg4 = (Dali::Property::Index)jarg4;
22660   arg5 = (unsigned int)jarg5;
22661   {
22662     try {
22663       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22664     } catch (std::out_of_range& e) {
22665       {
22666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22667       };
22668     } catch (std::exception& e) {
22669       {
22670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22671       };
22672     } catch (Dali::DaliException e) {
22673       {
22674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22675       };
22676     } catch (...) {
22677       {
22678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22679       };
22680     }
22681   }
22682
22683   jresult = (void *)result;
22684
22685   //argout typemap for const std::string&
22686
22687   return jresult;
22688 }
22689
22690
22691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22692   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22693
22694   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22695   {
22696     try {
22697       delete arg1;
22698     } catch (std::out_of_range& e) {
22699       {
22700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22701       };
22702     } catch (std::exception& e) {
22703       {
22704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22705       };
22706     } catch (Dali::DaliException e) {
22707       {
22708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22709       };
22710     } catch (...) {
22711       {
22712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22713       };
22714     }
22715   }
22716
22717 }
22718
22719
22720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22721   void * jresult ;
22722   Dali::TypeRegistration *arg1 = 0 ;
22723   std::string *arg2 = 0 ;
22724   Dali::Property::Index arg3 ;
22725   Dali::Property::Type arg4 ;
22726   Dali::ChildPropertyRegistration *result = 0 ;
22727
22728   arg1 = (Dali::TypeRegistration *)jarg1;
22729   if (!arg1) {
22730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22731     return 0;
22732   }
22733   if (!jarg2) {
22734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22735     return 0;
22736   }
22737   std::string arg2_str(jarg2);
22738   arg2 = &arg2_str;
22739   arg3 = (Dali::Property::Index)jarg3;
22740   arg4 = (Dali::Property::Type)jarg4;
22741   {
22742     try {
22743       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22744     } catch (std::out_of_range& e) {
22745       {
22746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22747       };
22748     } catch (std::exception& e) {
22749       {
22750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22751       };
22752     } catch (Dali::DaliException e) {
22753       {
22754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22755       };
22756     } catch (...) {
22757       {
22758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22759       };
22760     }
22761   }
22762
22763   jresult = (void *)result;
22764
22765   //argout typemap for const std::string&
22766
22767   return jresult;
22768 }
22769
22770
22771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22772   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22773
22774   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22775   {
22776     try {
22777       delete arg1;
22778     } catch (std::out_of_range& e) {
22779       {
22780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22781       };
22782     } catch (std::exception& e) {
22783       {
22784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22785       };
22786     } catch (Dali::DaliException e) {
22787       {
22788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22789       };
22790     } catch (...) {
22791       {
22792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22793       };
22794     }
22795   }
22796
22797 }
22798
22799
22800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22801   unsigned int jresult ;
22802   std::string *arg1 = 0 ;
22803   std::type_info *arg2 = 0 ;
22804   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22805   bool result;
22806
22807   if (!jarg1) {
22808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22809     return 0;
22810   }
22811   std::string arg1_str(jarg1);
22812   arg1 = &arg1_str;
22813   arg2 = (std::type_info *)jarg2;
22814   if (!arg2) {
22815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22816     return 0;
22817   }
22818   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22819   {
22820     try {
22821       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22822     } catch (std::out_of_range& e) {
22823       {
22824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22825       };
22826     } catch (std::exception& e) {
22827       {
22828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22829       };
22830     } catch (Dali::DaliException e) {
22831       {
22832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22833       };
22834     } catch (...) {
22835       {
22836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22837       };
22838     }
22839   }
22840
22841   jresult = result;
22842
22843   //argout typemap for const std::string&
22844
22845   return jresult;
22846 }
22847
22848
22849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22850   unsigned int jresult ;
22851   std::string *arg1 = 0 ;
22852   std::string *arg2 = 0 ;
22853   Dali::Property::Index arg3 ;
22854   Dali::Property::Type arg4 ;
22855   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22856   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22857   bool result;
22858
22859   if (!jarg1) {
22860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22861     return 0;
22862   }
22863   std::string arg1_str(jarg1);
22864   arg1 = &arg1_str;
22865   if (!jarg2) {
22866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22867     return 0;
22868   }
22869   std::string arg2_str(jarg2);
22870   arg2 = &arg2_str;
22871   arg3 = (Dali::Property::Index)jarg3;
22872   arg4 = (Dali::Property::Type)jarg4;
22873   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22874   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22875   {
22876     try {
22877       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22878     } catch (std::out_of_range& e) {
22879       {
22880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22881       };
22882     } catch (std::exception& e) {
22883       {
22884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22885       };
22886     } catch (Dali::DaliException e) {
22887       {
22888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22889       };
22890     } catch (...) {
22891       {
22892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22893       };
22894     }
22895   }
22896
22897   jresult = result;
22898
22899   //argout typemap for const std::string&
22900
22901
22902   //argout typemap for const std::string&
22903
22904   return jresult;
22905 }
22906
22907
22908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22909   float jresult ;
22910   float result;
22911
22912   result = (float)(float)Dali::ParentOrigin::TOP;
22913   jresult = result;
22914   return jresult;
22915 }
22916
22917
22918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22919   float jresult ;
22920   float result;
22921
22922   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22923   jresult = result;
22924   return jresult;
22925 }
22926
22927
22928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22929   float jresult ;
22930   float result;
22931
22932   result = (float)(float)Dali::ParentOrigin::LEFT;
22933   jresult = result;
22934   return jresult;
22935 }
22936
22937
22938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22939   float jresult ;
22940   float result;
22941
22942   result = (float)(float)Dali::ParentOrigin::RIGHT;
22943   jresult = result;
22944   return jresult;
22945 }
22946
22947
22948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22949   float jresult ;
22950   float result;
22951
22952   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22953   jresult = result;
22954   return jresult;
22955 }
22956
22957
22958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22959   void * jresult ;
22960   Dali::Vector3 *result = 0 ;
22961
22962   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22963   jresult = (void *)result;
22964   return jresult;
22965 }
22966
22967
22968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22969   void * jresult ;
22970   Dali::Vector3 *result = 0 ;
22971
22972   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22973   jresult = (void *)result;
22974   return jresult;
22975 }
22976
22977
22978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22979   void * jresult ;
22980   Dali::Vector3 *result = 0 ;
22981
22982   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22983   jresult = (void *)result;
22984   return jresult;
22985 }
22986
22987
22988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22989   void * jresult ;
22990   Dali::Vector3 *result = 0 ;
22991
22992   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22993   jresult = (void *)result;
22994   return jresult;
22995 }
22996
22997
22998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
22999   void * jresult ;
23000   Dali::Vector3 *result = 0 ;
23001
23002   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23003   jresult = (void *)result;
23004   return jresult;
23005 }
23006
23007
23008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23009   void * jresult ;
23010   Dali::Vector3 *result = 0 ;
23011
23012   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23013   jresult = (void *)result;
23014   return jresult;
23015 }
23016
23017
23018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23019   void * jresult ;
23020   Dali::Vector3 *result = 0 ;
23021
23022   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23023   jresult = (void *)result;
23024   return jresult;
23025 }
23026
23027
23028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23029   void * jresult ;
23030   Dali::Vector3 *result = 0 ;
23031
23032   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23033   jresult = (void *)result;
23034   return jresult;
23035 }
23036
23037
23038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23039   void * jresult ;
23040   Dali::Vector3 *result = 0 ;
23041
23042   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23043   jresult = (void *)result;
23044   return jresult;
23045 }
23046
23047
23048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23049   float jresult ;
23050   float result;
23051
23052   result = (float)(float)Dali::AnchorPoint::TOP;
23053   jresult = result;
23054   return jresult;
23055 }
23056
23057
23058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23059   float jresult ;
23060   float result;
23061
23062   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23063   jresult = result;
23064   return jresult;
23065 }
23066
23067
23068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23069   float jresult ;
23070   float result;
23071
23072   result = (float)(float)Dali::AnchorPoint::LEFT;
23073   jresult = result;
23074   return jresult;
23075 }
23076
23077
23078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23079   float jresult ;
23080   float result;
23081
23082   result = (float)(float)Dali::AnchorPoint::RIGHT;
23083   jresult = result;
23084   return jresult;
23085 }
23086
23087
23088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23089   float jresult ;
23090   float result;
23091
23092   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23093   jresult = result;
23094   return jresult;
23095 }
23096
23097
23098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23099   void * jresult ;
23100   Dali::Vector3 *result = 0 ;
23101
23102   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23103   jresult = (void *)result;
23104   return jresult;
23105 }
23106
23107
23108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23109   void * jresult ;
23110   Dali::Vector3 *result = 0 ;
23111
23112   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23113   jresult = (void *)result;
23114   return jresult;
23115 }
23116
23117
23118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23119   void * jresult ;
23120   Dali::Vector3 *result = 0 ;
23121
23122   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23123   jresult = (void *)result;
23124   return jresult;
23125 }
23126
23127
23128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23129   void * jresult ;
23130   Dali::Vector3 *result = 0 ;
23131
23132   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23133   jresult = (void *)result;
23134   return jresult;
23135 }
23136
23137
23138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23139   void * jresult ;
23140   Dali::Vector3 *result = 0 ;
23141
23142   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23143   jresult = (void *)result;
23144   return jresult;
23145 }
23146
23147
23148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23149   void * jresult ;
23150   Dali::Vector3 *result = 0 ;
23151
23152   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23153   jresult = (void *)result;
23154   return jresult;
23155 }
23156
23157
23158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23159   void * jresult ;
23160   Dali::Vector3 *result = 0 ;
23161
23162   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23163   jresult = (void *)result;
23164   return jresult;
23165 }
23166
23167
23168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23169   void * jresult ;
23170   Dali::Vector3 *result = 0 ;
23171
23172   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23173   jresult = (void *)result;
23174   return jresult;
23175 }
23176
23177
23178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23179   void * jresult ;
23180   Dali::Vector3 *result = 0 ;
23181
23182   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23183   jresult = (void *)result;
23184   return jresult;
23185 }
23186
23187
23188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23189   void * jresult ;
23190   Dali::Vector4 *result = 0 ;
23191
23192   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23193   jresult = (void *)result;
23194   return jresult;
23195 }
23196
23197
23198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23199   void * jresult ;
23200   Dali::Vector4 *result = 0 ;
23201
23202   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23203   jresult = (void *)result;
23204   return jresult;
23205 }
23206
23207
23208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23209   void * jresult ;
23210   Dali::Vector4 *result = 0 ;
23211
23212   result = (Dali::Vector4 *)&Dali::Color::RED;
23213   jresult = (void *)result;
23214   return jresult;
23215 }
23216
23217
23218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23219   void * jresult ;
23220   Dali::Vector4 *result = 0 ;
23221
23222   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23223   jresult = (void *)result;
23224   return jresult;
23225 }
23226
23227
23228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23229   void * jresult ;
23230   Dali::Vector4 *result = 0 ;
23231
23232   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23233   jresult = (void *)result;
23234   return jresult;
23235 }
23236
23237
23238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23239   void * jresult ;
23240   Dali::Vector4 *result = 0 ;
23241
23242   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23243   jresult = (void *)result;
23244   return jresult;
23245 }
23246
23247
23248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23249   void * jresult ;
23250   Dali::Vector4 *result = 0 ;
23251
23252   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23253   jresult = (void *)result;
23254   return jresult;
23255 }
23256
23257
23258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23259   void * jresult ;
23260   Dali::Vector4 *result = 0 ;
23261
23262   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23263   jresult = (void *)result;
23264   return jresult;
23265 }
23266
23267
23268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23269   void * jresult ;
23270   Dali::Vector4 *result = 0 ;
23271
23272   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23273   jresult = (void *)result;
23274   return jresult;
23275 }
23276
23277
23278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23279   float jresult ;
23280   float result;
23281
23282   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23283   jresult = result;
23284   return jresult;
23285 }
23286
23287
23288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23289   float jresult ;
23290   float result;
23291
23292   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23293   jresult = result;
23294   return jresult;
23295 }
23296
23297
23298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23299   float jresult ;
23300   float result;
23301
23302   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23303   jresult = result;
23304   return jresult;
23305 }
23306
23307
23308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23309   float jresult ;
23310   float result;
23311
23312   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23313   jresult = result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23319   float jresult ;
23320   float result;
23321
23322   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23323   jresult = result;
23324   return jresult;
23325 }
23326
23327
23328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23329   float jresult ;
23330   float result;
23331
23332   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23333   jresult = result;
23334   return jresult;
23335 }
23336
23337
23338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23339   float jresult ;
23340   float result;
23341
23342   result = (float)(float)Dali::Math::PI;
23343   jresult = result;
23344   return jresult;
23345 }
23346
23347
23348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23349   float jresult ;
23350   float result;
23351
23352   result = (float)(float)Dali::Math::PI_2;
23353   jresult = result;
23354   return jresult;
23355 }
23356
23357
23358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23359   float jresult ;
23360   float result;
23361
23362   result = (float)(float)Dali::Math::PI_4;
23363   jresult = result;
23364   return jresult;
23365 }
23366
23367
23368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23369   float jresult ;
23370   float result;
23371
23372   result = (float)(float)Dali::Math::PI_OVER_180;
23373   jresult = result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23379   float jresult ;
23380   float result;
23381
23382   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23383   jresult = result;
23384   return jresult;
23385 }
23386
23387
23388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23389   int jresult ;
23390   Dali::ResizePolicy::Type result;
23391
23392   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23393   jresult = (int)result;
23394   return jresult;
23395 }
23396
23397
23398 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23399   unsigned long jresult ;
23400   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23401   Dali::VectorBase::SizeType result;
23402
23403   arg1 = (Dali::VectorBase *)jarg1;
23404   {
23405     try {
23406       result = ((Dali::VectorBase const *)arg1)->Count();
23407     } catch (std::out_of_range& e) {
23408       {
23409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23410       };
23411     } catch (std::exception& e) {
23412       {
23413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23414       };
23415     } catch (Dali::DaliException e) {
23416       {
23417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23418       };
23419     } catch (...) {
23420       {
23421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23422       };
23423     }
23424   }
23425
23426   jresult = (unsigned long)result;
23427   return jresult;
23428 }
23429
23430
23431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23432   unsigned long jresult ;
23433   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23434   Dali::VectorBase::SizeType result;
23435
23436   arg1 = (Dali::VectorBase *)jarg1;
23437   {
23438     try {
23439       result = ((Dali::VectorBase const *)arg1)->Size();
23440     } catch (std::out_of_range& e) {
23441       {
23442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23443       };
23444     } catch (std::exception& e) {
23445       {
23446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23447       };
23448     } catch (Dali::DaliException e) {
23449       {
23450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23451       };
23452     } catch (...) {
23453       {
23454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23455       };
23456     }
23457   }
23458
23459   jresult = (unsigned long)result;
23460   return jresult;
23461 }
23462
23463
23464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23465   unsigned int jresult ;
23466   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23467   bool result;
23468
23469   arg1 = (Dali::VectorBase *)jarg1;
23470   {
23471     try {
23472       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23473     } catch (std::out_of_range& e) {
23474       {
23475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23476       };
23477     } catch (std::exception& e) {
23478       {
23479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23480       };
23481     } catch (Dali::DaliException e) {
23482       {
23483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23484       };
23485     } catch (...) {
23486       {
23487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23488       };
23489     }
23490   }
23491
23492   jresult = result;
23493   return jresult;
23494 }
23495
23496
23497 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23498   unsigned long jresult ;
23499   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23500   Dali::VectorBase::SizeType result;
23501
23502   arg1 = (Dali::VectorBase *)jarg1;
23503   {
23504     try {
23505       result = ((Dali::VectorBase const *)arg1)->Capacity();
23506     } catch (std::out_of_range& e) {
23507       {
23508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23509       };
23510     } catch (std::exception& e) {
23511       {
23512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23513       };
23514     } catch (Dali::DaliException e) {
23515       {
23516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23517       };
23518     } catch (...) {
23519       {
23520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23521       };
23522     }
23523   }
23524
23525   jresult = (unsigned long)result;
23526   return jresult;
23527 }
23528
23529
23530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23531   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23532
23533   arg1 = (Dali::VectorBase *)jarg1;
23534   {
23535     try {
23536       (arg1)->Release();
23537     } catch (std::out_of_range& e) {
23538       {
23539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23540       };
23541     } catch (std::exception& e) {
23542       {
23543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23544       };
23545     } catch (Dali::DaliException e) {
23546       {
23547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23548       };
23549     } catch (...) {
23550       {
23551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23552       };
23553     }
23554   }
23555
23556 }
23557
23558
23559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23560   void * jresult ;
23561   Dali::Image *result = 0 ;
23562
23563   {
23564     try {
23565       result = (Dali::Image *)new Dali::Image();
23566     } catch (std::out_of_range& e) {
23567       {
23568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23569       };
23570     } catch (std::exception& e) {
23571       {
23572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23573       };
23574     } catch (Dali::DaliException e) {
23575       {
23576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23577       };
23578     } catch (...) {
23579       {
23580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23581       };
23582     }
23583   }
23584
23585   jresult = (void *)result;
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23591   Dali::Image *arg1 = (Dali::Image *) 0 ;
23592
23593   arg1 = (Dali::Image *)jarg1;
23594   {
23595     try {
23596       delete arg1;
23597     } catch (std::out_of_range& e) {
23598       {
23599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23600       };
23601     } catch (std::exception& e) {
23602       {
23603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23604       };
23605     } catch (Dali::DaliException e) {
23606       {
23607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23608       };
23609     } catch (...) {
23610       {
23611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23612       };
23613     }
23614   }
23615
23616 }
23617
23618
23619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23620   void * jresult ;
23621   Dali::Image *arg1 = 0 ;
23622   Dali::Image *result = 0 ;
23623
23624   arg1 = (Dali::Image *)jarg1;
23625   if (!arg1) {
23626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23627     return 0;
23628   }
23629   {
23630     try {
23631       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23632     } catch (std::out_of_range& e) {
23633       {
23634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23635       };
23636     } catch (std::exception& e) {
23637       {
23638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23639       };
23640     } catch (Dali::DaliException e) {
23641       {
23642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23643       };
23644     } catch (...) {
23645       {
23646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23647       };
23648     }
23649   }
23650
23651   jresult = (void *)result;
23652   return jresult;
23653 }
23654
23655
23656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23657   void * jresult ;
23658   Dali::Image *arg1 = (Dali::Image *) 0 ;
23659   Dali::Image *arg2 = 0 ;
23660   Dali::Image *result = 0 ;
23661
23662   arg1 = (Dali::Image *)jarg1;
23663   arg2 = (Dali::Image *)jarg2;
23664   if (!arg2) {
23665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23666     return 0;
23667   }
23668   {
23669     try {
23670       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23671     } catch (std::out_of_range& e) {
23672       {
23673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23674       };
23675     } catch (std::exception& e) {
23676       {
23677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23678       };
23679     } catch (Dali::DaliException e) {
23680       {
23681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23682       };
23683     } catch (...) {
23684       {
23685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23686       };
23687     }
23688   }
23689
23690   jresult = (void *)result;
23691   return jresult;
23692 }
23693
23694
23695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23696   void * jresult ;
23697   Dali::BaseHandle arg1 ;
23698   Dali::BaseHandle *argp1 ;
23699   Dali::Image result;
23700
23701   argp1 = (Dali::BaseHandle *)jarg1;
23702   if (!argp1) {
23703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23704     return 0;
23705   }
23706   arg1 = *argp1;
23707   {
23708     try {
23709       result = Dali::Image::DownCast(arg1);
23710     } catch (std::out_of_range& e) {
23711       {
23712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23713       };
23714     } catch (std::exception& e) {
23715       {
23716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23717       };
23718     } catch (Dali::DaliException e) {
23719       {
23720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23721       };
23722     } catch (...) {
23723       {
23724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23725       };
23726     }
23727   }
23728
23729   jresult = new Dali::Image((const Dali::Image &)result);
23730   return jresult;
23731 }
23732
23733
23734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23735   unsigned int jresult ;
23736   Dali::Image *arg1 = (Dali::Image *) 0 ;
23737   unsigned int result;
23738
23739   arg1 = (Dali::Image *)jarg1;
23740   {
23741     try {
23742       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23743     } catch (std::out_of_range& e) {
23744       {
23745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23746       };
23747     } catch (std::exception& e) {
23748       {
23749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23750       };
23751     } catch (Dali::DaliException e) {
23752       {
23753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23754       };
23755     } catch (...) {
23756       {
23757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23758       };
23759     }
23760   }
23761
23762   jresult = result;
23763   return jresult;
23764 }
23765
23766
23767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23768   unsigned int jresult ;
23769   Dali::Image *arg1 = (Dali::Image *) 0 ;
23770   unsigned int result;
23771
23772   arg1 = (Dali::Image *)jarg1;
23773   {
23774     try {
23775       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23776     } catch (std::out_of_range& e) {
23777       {
23778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23779       };
23780     } catch (std::exception& e) {
23781       {
23782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23783       };
23784     } catch (Dali::DaliException e) {
23785       {
23786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23787       };
23788     } catch (...) {
23789       {
23790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23791       };
23792     }
23793   }
23794
23795   jresult = result;
23796   return jresult;
23797 }
23798
23799
23800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23801   void * jresult ;
23802   Dali::Image *arg1 = (Dali::Image *) 0 ;
23803   Dali::Image::ImageSignalType *result = 0 ;
23804
23805   arg1 = (Dali::Image *)jarg1;
23806   {
23807     try {
23808       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23809     } catch (std::out_of_range& e) {
23810       {
23811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23812       };
23813     } catch (std::exception& e) {
23814       {
23815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23816       };
23817     } catch (Dali::DaliException e) {
23818       {
23819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23820       };
23821     } catch (...) {
23822       {
23823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23824       };
23825     }
23826   }
23827
23828   jresult = (void *)result;
23829   return jresult;
23830 }
23831
23832
23833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23834   int jresult ;
23835   Dali::Pixel::Format result;
23836
23837   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23838   jresult = (int)result;
23839   return jresult;
23840 }
23841
23842
23843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23844   int jresult ;
23845   Dali::Pixel::Format result;
23846
23847   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23848   jresult = (int)result;
23849   return jresult;
23850 }
23851
23852
23853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23854   unsigned int jresult ;
23855   Dali::Pixel::Format arg1 ;
23856   bool result;
23857
23858   arg1 = (Dali::Pixel::Format)jarg1;
23859   {
23860     try {
23861       result = (bool)Dali::Pixel::HasAlpha(arg1);
23862     } catch (std::out_of_range& e) {
23863       {
23864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23865       };
23866     } catch (std::exception& e) {
23867       {
23868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23869       };
23870     } catch (Dali::DaliException e) {
23871       {
23872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23873       };
23874     } catch (...) {
23875       {
23876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23877       };
23878     }
23879   }
23880
23881   jresult = result;
23882   return jresult;
23883 }
23884
23885
23886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23887   unsigned int jresult ;
23888   Dali::Pixel::Format arg1 ;
23889   unsigned int result;
23890
23891   arg1 = (Dali::Pixel::Format)jarg1;
23892   {
23893     try {
23894       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23895     } catch (std::out_of_range& e) {
23896       {
23897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23898       };
23899     } catch (std::exception& e) {
23900       {
23901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23902       };
23903     } catch (Dali::DaliException e) {
23904       {
23905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23906       };
23907     } catch (...) {
23908       {
23909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23910       };
23911     }
23912   }
23913
23914   jresult = result;
23915   return jresult;
23916 }
23917
23918
23919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23920   Dali::Pixel::Format arg1 ;
23921   int *arg2 = 0 ;
23922   int *arg3 = 0 ;
23923
23924   arg1 = (Dali::Pixel::Format)jarg1;
23925   arg2 = (int *)jarg2;
23926   if (!arg2) {
23927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23928     return ;
23929   }
23930   arg3 = (int *)jarg3;
23931   if (!arg3) {
23932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23933     return ;
23934   }
23935   {
23936     try {
23937       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23938     } catch (std::out_of_range& e) {
23939       {
23940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23941       };
23942     } catch (std::exception& e) {
23943       {
23944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23945       };
23946     } catch (Dali::DaliException e) {
23947       {
23948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23949       };
23950     } catch (...) {
23951       {
23952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23953       };
23954     }
23955   }
23956
23957 }
23958
23959
23960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23961   void * jresult ;
23962   unsigned char *arg1 = (unsigned char *) 0 ;
23963   unsigned int arg2 ;
23964   unsigned int arg3 ;
23965   unsigned int arg4 ;
23966   Dali::Pixel::Format arg5 ;
23967   Dali::PixelData::ReleaseFunction arg6 ;
23968   Dali::PixelData result;
23969
23970   arg1 = jarg1;
23971   arg2 = (unsigned int)jarg2;
23972   arg3 = (unsigned int)jarg3;
23973   arg4 = (unsigned int)jarg4;
23974   arg5 = (Dali::Pixel::Format)jarg5;
23975   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23976   {
23977     try {
23978       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
23979     } catch (std::out_of_range& e) {
23980       {
23981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23982       };
23983     } catch (std::exception& e) {
23984       {
23985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23986       };
23987     } catch (Dali::DaliException e) {
23988       {
23989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23990       };
23991     } catch (...) {
23992       {
23993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23994       };
23995     }
23996   }
23997
23998   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23999
24000
24001   return jresult;
24002 }
24003
24004
24005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24006   void * jresult ;
24007   Dali::PixelData *result = 0 ;
24008
24009   {
24010     try {
24011       result = (Dali::PixelData *)new Dali::PixelData();
24012     } catch (std::out_of_range& e) {
24013       {
24014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24015       };
24016     } catch (std::exception& e) {
24017       {
24018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24019       };
24020     } catch (Dali::DaliException e) {
24021       {
24022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24023       };
24024     } catch (...) {
24025       {
24026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24027       };
24028     }
24029   }
24030
24031   jresult = (void *)result;
24032   return jresult;
24033 }
24034
24035
24036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24037   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24038
24039   arg1 = (Dali::PixelData *)jarg1;
24040   {
24041     try {
24042       delete arg1;
24043     } catch (std::out_of_range& e) {
24044       {
24045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24046       };
24047     } catch (std::exception& e) {
24048       {
24049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24050       };
24051     } catch (Dali::DaliException e) {
24052       {
24053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24054       };
24055     } catch (...) {
24056       {
24057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24058       };
24059     }
24060   }
24061
24062 }
24063
24064
24065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24066   void * jresult ;
24067   Dali::PixelData *arg1 = 0 ;
24068   Dali::PixelData *result = 0 ;
24069
24070   arg1 = (Dali::PixelData *)jarg1;
24071   if (!arg1) {
24072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24073     return 0;
24074   }
24075   {
24076     try {
24077       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24078     } catch (std::out_of_range& e) {
24079       {
24080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24081       };
24082     } catch (std::exception& e) {
24083       {
24084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24085       };
24086     } catch (Dali::DaliException e) {
24087       {
24088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24089       };
24090     } catch (...) {
24091       {
24092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24093       };
24094     }
24095   }
24096
24097   jresult = (void *)result;
24098   return jresult;
24099 }
24100
24101
24102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24103   void * jresult ;
24104   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24105   Dali::PixelData *arg2 = 0 ;
24106   Dali::PixelData *result = 0 ;
24107
24108   arg1 = (Dali::PixelData *)jarg1;
24109   arg2 = (Dali::PixelData *)jarg2;
24110   if (!arg2) {
24111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24112     return 0;
24113   }
24114   {
24115     try {
24116       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24117     } catch (std::out_of_range& e) {
24118       {
24119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24120       };
24121     } catch (std::exception& e) {
24122       {
24123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24124       };
24125     } catch (Dali::DaliException e) {
24126       {
24127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24128       };
24129     } catch (...) {
24130       {
24131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24132       };
24133     }
24134   }
24135
24136   jresult = (void *)result;
24137   return jresult;
24138 }
24139
24140
24141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24142   unsigned int jresult ;
24143   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24144   unsigned int result;
24145
24146   arg1 = (Dali::PixelData *)jarg1;
24147   {
24148     try {
24149       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24150     } catch (std::out_of_range& e) {
24151       {
24152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24153       };
24154     } catch (std::exception& e) {
24155       {
24156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24157       };
24158     } catch (Dali::DaliException e) {
24159       {
24160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24161       };
24162     } catch (...) {
24163       {
24164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24165       };
24166     }
24167   }
24168
24169   jresult = result;
24170   return jresult;
24171 }
24172
24173
24174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24175   unsigned int jresult ;
24176   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24177   unsigned int result;
24178
24179   arg1 = (Dali::PixelData *)jarg1;
24180   {
24181     try {
24182       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24183     } catch (std::out_of_range& e) {
24184       {
24185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24186       };
24187     } catch (std::exception& e) {
24188       {
24189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24190       };
24191     } catch (Dali::DaliException e) {
24192       {
24193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24194       };
24195     } catch (...) {
24196       {
24197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24198       };
24199     }
24200   }
24201
24202   jresult = result;
24203   return jresult;
24204 }
24205
24206
24207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24208   int jresult ;
24209   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24210   Dali::Pixel::Format result;
24211
24212   arg1 = (Dali::PixelData *)jarg1;
24213   {
24214     try {
24215       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24216     } catch (std::out_of_range& e) {
24217       {
24218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24219       };
24220     } catch (std::exception& e) {
24221       {
24222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24223       };
24224     } catch (Dali::DaliException e) {
24225       {
24226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24227       };
24228     } catch (...) {
24229       {
24230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24231       };
24232     }
24233   }
24234
24235   jresult = (int)result;
24236   return jresult;
24237 }
24238
24239
24240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24241   unsigned int jresult ;
24242   unsigned int result;
24243
24244   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24245   jresult = result;
24246   return jresult;
24247 }
24248
24249
24250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24251   unsigned int jresult ;
24252   unsigned int result;
24253
24254   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24255   jresult = result;
24256   return jresult;
24257 }
24258
24259
24260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24261   unsigned int jresult ;
24262   unsigned int result;
24263
24264   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24265   jresult = result;
24266   return jresult;
24267 }
24268
24269
24270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24271   unsigned int jresult ;
24272   unsigned int result;
24273
24274   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24275   jresult = result;
24276   return jresult;
24277 }
24278
24279
24280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24281   unsigned int jresult ;
24282   unsigned int result;
24283
24284   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24285   jresult = result;
24286   return jresult;
24287 }
24288
24289
24290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24291   unsigned int jresult ;
24292   unsigned int result;
24293
24294   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24295   jresult = result;
24296   return jresult;
24297 }
24298
24299
24300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24301   void * jresult ;
24302   Dali::TextureType::Type arg1 ;
24303   Dali::Pixel::Format arg2 ;
24304   unsigned int arg3 ;
24305   unsigned int arg4 ;
24306   Dali::Texture result;
24307
24308   arg1 = (Dali::TextureType::Type)jarg1;
24309   arg2 = (Dali::Pixel::Format)jarg2;
24310   arg3 = (unsigned int)jarg3;
24311   arg4 = (unsigned int)jarg4;
24312   {
24313     try {
24314       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24315     } catch (std::out_of_range& e) {
24316       {
24317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24318       };
24319     } catch (std::exception& e) {
24320       {
24321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24322       };
24323     } catch (Dali::DaliException e) {
24324       {
24325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24326       };
24327     } catch (...) {
24328       {
24329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24330       };
24331     }
24332   }
24333
24334   jresult = new Dali::Texture((const Dali::Texture &)result);
24335   return jresult;
24336 }
24337
24338
24339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24340   void * jresult ;
24341   NativeImageInterface *arg1 = 0 ;
24342   Dali::Texture result;
24343
24344   arg1 = (NativeImageInterface *)jarg1;
24345   if (!arg1) {
24346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24347     return 0;
24348   }
24349   {
24350     try {
24351       result = Dali::Texture::New(*arg1);
24352     } catch (std::out_of_range& e) {
24353       {
24354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24355       };
24356     } catch (std::exception& e) {
24357       {
24358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24359       };
24360     } catch (Dali::DaliException e) {
24361       {
24362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24363       };
24364     } catch (...) {
24365       {
24366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24367       };
24368     }
24369   }
24370
24371   jresult = new Dali::Texture((const Dali::Texture &)result);
24372   return jresult;
24373 }
24374
24375
24376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24377   void * jresult ;
24378   Dali::Texture *result = 0 ;
24379
24380   {
24381     try {
24382       result = (Dali::Texture *)new Dali::Texture();
24383     } catch (std::out_of_range& e) {
24384       {
24385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24386       };
24387     } catch (std::exception& e) {
24388       {
24389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24390       };
24391     } catch (Dali::DaliException e) {
24392       {
24393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24394       };
24395     } catch (...) {
24396       {
24397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24398       };
24399     }
24400   }
24401
24402   jresult = (void *)result;
24403   return jresult;
24404 }
24405
24406
24407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24408   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24409
24410   arg1 = (Dali::Texture *)jarg1;
24411   {
24412     try {
24413       delete arg1;
24414     } catch (std::out_of_range& e) {
24415       {
24416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24417       };
24418     } catch (std::exception& e) {
24419       {
24420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24421       };
24422     } catch (Dali::DaliException e) {
24423       {
24424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24425       };
24426     } catch (...) {
24427       {
24428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24429       };
24430     }
24431   }
24432
24433 }
24434
24435
24436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24437   void * jresult ;
24438   Dali::Texture *arg1 = 0 ;
24439   Dali::Texture *result = 0 ;
24440
24441   arg1 = (Dali::Texture *)jarg1;
24442   if (!arg1) {
24443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24444     return 0;
24445   }
24446   {
24447     try {
24448       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24449     } catch (std::out_of_range& e) {
24450       {
24451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24452       };
24453     } catch (std::exception& e) {
24454       {
24455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24456       };
24457     } catch (Dali::DaliException e) {
24458       {
24459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24460       };
24461     } catch (...) {
24462       {
24463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24464       };
24465     }
24466   }
24467
24468   jresult = (void *)result;
24469   return jresult;
24470 }
24471
24472
24473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24474   void * jresult ;
24475   Dali::BaseHandle arg1 ;
24476   Dali::BaseHandle *argp1 ;
24477   Dali::Texture result;
24478
24479   argp1 = (Dali::BaseHandle *)jarg1;
24480   if (!argp1) {
24481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24482     return 0;
24483   }
24484   arg1 = *argp1;
24485   {
24486     try {
24487       result = Dali::Texture::DownCast(arg1);
24488     } catch (std::out_of_range& e) {
24489       {
24490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24491       };
24492     } catch (std::exception& e) {
24493       {
24494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24495       };
24496     } catch (Dali::DaliException e) {
24497       {
24498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24499       };
24500     } catch (...) {
24501       {
24502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24503       };
24504     }
24505   }
24506
24507   jresult = new Dali::Texture((const Dali::Texture &)result);
24508   return jresult;
24509 }
24510
24511
24512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24513   void * jresult ;
24514   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24515   Dali::Texture *arg2 = 0 ;
24516   Dali::Texture *result = 0 ;
24517
24518   arg1 = (Dali::Texture *)jarg1;
24519   arg2 = (Dali::Texture *)jarg2;
24520   if (!arg2) {
24521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24522     return 0;
24523   }
24524   {
24525     try {
24526       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24527     } catch (std::out_of_range& e) {
24528       {
24529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24530       };
24531     } catch (std::exception& e) {
24532       {
24533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24534       };
24535     } catch (Dali::DaliException e) {
24536       {
24537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24538       };
24539     } catch (...) {
24540       {
24541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24542       };
24543     }
24544   }
24545
24546   jresult = (void *)result;
24547   return jresult;
24548 }
24549
24550
24551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24552   unsigned int jresult ;
24553   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24554   Dali::PixelData arg2 ;
24555   Dali::PixelData *argp2 ;
24556   bool result;
24557
24558   arg1 = (Dali::Texture *)jarg1;
24559   argp2 = (Dali::PixelData *)jarg2;
24560   if (!argp2) {
24561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24562     return 0;
24563   }
24564   arg2 = *argp2;
24565   {
24566     try {
24567       result = (bool)(arg1)->Upload(arg2);
24568     } catch (std::out_of_range& e) {
24569       {
24570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24571       };
24572     } catch (std::exception& e) {
24573       {
24574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24575       };
24576     } catch (Dali::DaliException e) {
24577       {
24578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24579       };
24580     } catch (...) {
24581       {
24582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24583       };
24584     }
24585   }
24586
24587   jresult = result;
24588   return jresult;
24589 }
24590
24591
24592 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) {
24593   unsigned int jresult ;
24594   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24595   Dali::PixelData arg2 ;
24596   unsigned int arg3 ;
24597   unsigned int arg4 ;
24598   unsigned int arg5 ;
24599   unsigned int arg6 ;
24600   unsigned int arg7 ;
24601   unsigned int arg8 ;
24602   Dali::PixelData *argp2 ;
24603   bool result;
24604
24605   arg1 = (Dali::Texture *)jarg1;
24606   argp2 = (Dali::PixelData *)jarg2;
24607   if (!argp2) {
24608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24609     return 0;
24610   }
24611   arg2 = *argp2;
24612   arg3 = (unsigned int)jarg3;
24613   arg4 = (unsigned int)jarg4;
24614   arg5 = (unsigned int)jarg5;
24615   arg6 = (unsigned int)jarg6;
24616   arg7 = (unsigned int)jarg7;
24617   arg8 = (unsigned int)jarg8;
24618   {
24619     try {
24620       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24621     } catch (std::out_of_range& e) {
24622       {
24623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24624       };
24625     } catch (std::exception& e) {
24626       {
24627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24628       };
24629     } catch (Dali::DaliException e) {
24630       {
24631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24632       };
24633     } catch (...) {
24634       {
24635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24636       };
24637     }
24638   }
24639
24640   jresult = result;
24641   return jresult;
24642 }
24643
24644
24645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24646   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24647
24648   arg1 = (Dali::Texture *)jarg1;
24649   {
24650     try {
24651       (arg1)->GenerateMipmaps();
24652     } catch (std::out_of_range& e) {
24653       {
24654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24655       };
24656     } catch (std::exception& e) {
24657       {
24658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24659       };
24660     } catch (Dali::DaliException e) {
24661       {
24662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24663       };
24664     } catch (...) {
24665       {
24666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24667       };
24668     }
24669   }
24670
24671 }
24672
24673
24674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24675   unsigned int jresult ;
24676   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24677   unsigned int result;
24678
24679   arg1 = (Dali::Texture *)jarg1;
24680   {
24681     try {
24682       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24683     } catch (std::out_of_range& e) {
24684       {
24685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24686       };
24687     } catch (std::exception& e) {
24688       {
24689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24690       };
24691     } catch (Dali::DaliException e) {
24692       {
24693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24694       };
24695     } catch (...) {
24696       {
24697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24698       };
24699     }
24700   }
24701
24702   jresult = result;
24703   return jresult;
24704 }
24705
24706
24707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24708   unsigned int jresult ;
24709   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24710   unsigned int result;
24711
24712   arg1 = (Dali::Texture *)jarg1;
24713   {
24714     try {
24715       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24716     } catch (std::out_of_range& e) {
24717       {
24718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24719       };
24720     } catch (std::exception& e) {
24721       {
24722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24723       };
24724     } catch (Dali::DaliException e) {
24725       {
24726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24727       };
24728     } catch (...) {
24729       {
24730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24731       };
24732     }
24733   }
24734
24735   jresult = result;
24736   return jresult;
24737 }
24738
24739
24740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24741   void * jresult ;
24742   Dali::Sampler result;
24743
24744   {
24745     try {
24746       result = Dali::Sampler::New();
24747     } catch (std::out_of_range& e) {
24748       {
24749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24750       };
24751     } catch (std::exception& e) {
24752       {
24753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24754       };
24755     } catch (Dali::DaliException e) {
24756       {
24757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24758       };
24759     } catch (...) {
24760       {
24761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24762       };
24763     }
24764   }
24765
24766   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24767   return jresult;
24768 }
24769
24770
24771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24772   void * jresult ;
24773   Dali::Sampler *result = 0 ;
24774
24775   {
24776     try {
24777       result = (Dali::Sampler *)new Dali::Sampler();
24778     } catch (std::out_of_range& e) {
24779       {
24780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24781       };
24782     } catch (std::exception& e) {
24783       {
24784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24785       };
24786     } catch (Dali::DaliException e) {
24787       {
24788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24789       };
24790     } catch (...) {
24791       {
24792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24793       };
24794     }
24795   }
24796
24797   jresult = (void *)result;
24798   return jresult;
24799 }
24800
24801
24802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24803   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24804
24805   arg1 = (Dali::Sampler *)jarg1;
24806   {
24807     try {
24808       delete arg1;
24809     } catch (std::out_of_range& e) {
24810       {
24811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24812       };
24813     } catch (std::exception& e) {
24814       {
24815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24816       };
24817     } catch (Dali::DaliException e) {
24818       {
24819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24820       };
24821     } catch (...) {
24822       {
24823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24824       };
24825     }
24826   }
24827
24828 }
24829
24830
24831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24832   void * jresult ;
24833   Dali::Sampler *arg1 = 0 ;
24834   Dali::Sampler *result = 0 ;
24835
24836   arg1 = (Dali::Sampler *)jarg1;
24837   if (!arg1) {
24838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24839     return 0;
24840   }
24841   {
24842     try {
24843       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24844     } catch (std::out_of_range& e) {
24845       {
24846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24847       };
24848     } catch (std::exception& e) {
24849       {
24850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24851       };
24852     } catch (Dali::DaliException e) {
24853       {
24854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24855       };
24856     } catch (...) {
24857       {
24858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24859       };
24860     }
24861   }
24862
24863   jresult = (void *)result;
24864   return jresult;
24865 }
24866
24867
24868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24869   void * jresult ;
24870   Dali::BaseHandle arg1 ;
24871   Dali::BaseHandle *argp1 ;
24872   Dali::Sampler result;
24873
24874   argp1 = (Dali::BaseHandle *)jarg1;
24875   if (!argp1) {
24876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24877     return 0;
24878   }
24879   arg1 = *argp1;
24880   {
24881     try {
24882       result = Dali::Sampler::DownCast(arg1);
24883     } catch (std::out_of_range& e) {
24884       {
24885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24886       };
24887     } catch (std::exception& e) {
24888       {
24889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24890       };
24891     } catch (Dali::DaliException e) {
24892       {
24893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24894       };
24895     } catch (...) {
24896       {
24897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24898       };
24899     }
24900   }
24901
24902   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24903   return jresult;
24904 }
24905
24906
24907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24908   void * jresult ;
24909   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24910   Dali::Sampler *arg2 = 0 ;
24911   Dali::Sampler *result = 0 ;
24912
24913   arg1 = (Dali::Sampler *)jarg1;
24914   arg2 = (Dali::Sampler *)jarg2;
24915   if (!arg2) {
24916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24917     return 0;
24918   }
24919   {
24920     try {
24921       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24922     } catch (std::out_of_range& e) {
24923       {
24924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24925       };
24926     } catch (std::exception& e) {
24927       {
24928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24929       };
24930     } catch (Dali::DaliException e) {
24931       {
24932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24933       };
24934     } catch (...) {
24935       {
24936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24937       };
24938     }
24939   }
24940
24941   jresult = (void *)result;
24942   return jresult;
24943 }
24944
24945
24946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24947   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24948   Dali::FilterMode::Type arg2 ;
24949   Dali::FilterMode::Type arg3 ;
24950
24951   arg1 = (Dali::Sampler *)jarg1;
24952   arg2 = (Dali::FilterMode::Type)jarg2;
24953   arg3 = (Dali::FilterMode::Type)jarg3;
24954   {
24955     try {
24956       (arg1)->SetFilterMode(arg2,arg3);
24957     } catch (std::out_of_range& e) {
24958       {
24959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24960       };
24961     } catch (std::exception& e) {
24962       {
24963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24964       };
24965     } catch (Dali::DaliException e) {
24966       {
24967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24968       };
24969     } catch (...) {
24970       {
24971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24972       };
24973     }
24974   }
24975
24976 }
24977
24978
24979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24980   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24981   Dali::WrapMode::Type arg2 ;
24982   Dali::WrapMode::Type arg3 ;
24983
24984   arg1 = (Dali::Sampler *)jarg1;
24985   arg2 = (Dali::WrapMode::Type)jarg2;
24986   arg3 = (Dali::WrapMode::Type)jarg3;
24987   {
24988     try {
24989       (arg1)->SetWrapMode(arg2,arg3);
24990     } catch (std::out_of_range& e) {
24991       {
24992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24993       };
24994     } catch (std::exception& e) {
24995       {
24996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24997       };
24998     } catch (Dali::DaliException e) {
24999       {
25000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25001       };
25002     } catch (...) {
25003       {
25004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25005       };
25006     }
25007   }
25008
25009 }
25010
25011
25012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25013   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25014   Dali::WrapMode::Type arg2 ;
25015   Dali::WrapMode::Type arg3 ;
25016   Dali::WrapMode::Type arg4 ;
25017
25018   arg1 = (Dali::Sampler *)jarg1;
25019   arg2 = (Dali::WrapMode::Type)jarg2;
25020   arg3 = (Dali::WrapMode::Type)jarg3;
25021   arg4 = (Dali::WrapMode::Type)jarg4;
25022   {
25023     try {
25024       (arg1)->SetWrapMode(arg2,arg3,arg4);
25025     } catch (std::out_of_range& e) {
25026       {
25027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25028       };
25029     } catch (std::exception& e) {
25030       {
25031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25032       };
25033     } catch (Dali::DaliException e) {
25034       {
25035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25036       };
25037     } catch (...) {
25038       {
25039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25040       };
25041     }
25042   }
25043
25044 }
25045
25046
25047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25048   void * jresult ;
25049   Dali::TextureSet result;
25050
25051   {
25052     try {
25053       result = Dali::TextureSet::New();
25054     } catch (std::out_of_range& e) {
25055       {
25056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25057       };
25058     } catch (std::exception& e) {
25059       {
25060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25061       };
25062     } catch (Dali::DaliException e) {
25063       {
25064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25065       };
25066     } catch (...) {
25067       {
25068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25069       };
25070     }
25071   }
25072
25073   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25074   return jresult;
25075 }
25076
25077
25078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25079   void * jresult ;
25080   Dali::TextureSet *result = 0 ;
25081
25082   {
25083     try {
25084       result = (Dali::TextureSet *)new Dali::TextureSet();
25085     } catch (std::out_of_range& e) {
25086       {
25087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25088       };
25089     } catch (std::exception& e) {
25090       {
25091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25092       };
25093     } catch (Dali::DaliException e) {
25094       {
25095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25096       };
25097     } catch (...) {
25098       {
25099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25100       };
25101     }
25102   }
25103
25104   jresult = (void *)result;
25105   return jresult;
25106 }
25107
25108
25109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25110   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25111
25112   arg1 = (Dali::TextureSet *)jarg1;
25113   {
25114     try {
25115       delete arg1;
25116     } catch (std::out_of_range& e) {
25117       {
25118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25119       };
25120     } catch (std::exception& e) {
25121       {
25122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25123       };
25124     } catch (Dali::DaliException e) {
25125       {
25126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25127       };
25128     } catch (...) {
25129       {
25130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25131       };
25132     }
25133   }
25134
25135 }
25136
25137
25138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25139   void * jresult ;
25140   Dali::TextureSet *arg1 = 0 ;
25141   Dali::TextureSet *result = 0 ;
25142
25143   arg1 = (Dali::TextureSet *)jarg1;
25144   if (!arg1) {
25145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25146     return 0;
25147   }
25148   {
25149     try {
25150       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25151     } catch (std::out_of_range& e) {
25152       {
25153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25154       };
25155     } catch (std::exception& e) {
25156       {
25157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25158       };
25159     } catch (Dali::DaliException e) {
25160       {
25161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25162       };
25163     } catch (...) {
25164       {
25165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25166       };
25167     }
25168   }
25169
25170   jresult = (void *)result;
25171   return jresult;
25172 }
25173
25174
25175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25176   void * jresult ;
25177   Dali::BaseHandle arg1 ;
25178   Dali::BaseHandle *argp1 ;
25179   Dali::TextureSet result;
25180
25181   argp1 = (Dali::BaseHandle *)jarg1;
25182   if (!argp1) {
25183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25184     return 0;
25185   }
25186   arg1 = *argp1;
25187   {
25188     try {
25189       result = Dali::TextureSet::DownCast(arg1);
25190     } catch (std::out_of_range& e) {
25191       {
25192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25193       };
25194     } catch (std::exception& e) {
25195       {
25196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25197       };
25198     } catch (Dali::DaliException e) {
25199       {
25200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25201       };
25202     } catch (...) {
25203       {
25204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25205       };
25206     }
25207   }
25208
25209   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25210   return jresult;
25211 }
25212
25213
25214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25215   void * jresult ;
25216   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25217   Dali::TextureSet *arg2 = 0 ;
25218   Dali::TextureSet *result = 0 ;
25219
25220   arg1 = (Dali::TextureSet *)jarg1;
25221   arg2 = (Dali::TextureSet *)jarg2;
25222   if (!arg2) {
25223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25224     return 0;
25225   }
25226   {
25227     try {
25228       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25229     } catch (std::out_of_range& e) {
25230       {
25231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25232       };
25233     } catch (std::exception& e) {
25234       {
25235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25236       };
25237     } catch (Dali::DaliException e) {
25238       {
25239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25240       };
25241     } catch (...) {
25242       {
25243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25244       };
25245     }
25246   }
25247
25248   jresult = (void *)result;
25249   return jresult;
25250 }
25251
25252
25253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25254   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25255   size_t arg2 ;
25256   Dali::Texture arg3 ;
25257   Dali::Texture *argp3 ;
25258
25259   arg1 = (Dali::TextureSet *)jarg1;
25260   arg2 = (size_t)jarg2;
25261   argp3 = (Dali::Texture *)jarg3;
25262   if (!argp3) {
25263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25264     return ;
25265   }
25266   arg3 = *argp3;
25267   {
25268     try {
25269       (arg1)->SetTexture(arg2,arg3);
25270     } catch (std::out_of_range& e) {
25271       {
25272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25273       };
25274     } catch (std::exception& e) {
25275       {
25276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25277       };
25278     } catch (Dali::DaliException e) {
25279       {
25280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25281       };
25282     } catch (...) {
25283       {
25284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25285       };
25286     }
25287   }
25288
25289 }
25290
25291
25292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25293   void * jresult ;
25294   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25295   size_t arg2 ;
25296   Dali::Texture result;
25297
25298   arg1 = (Dali::TextureSet *)jarg1;
25299   arg2 = (size_t)jarg2;
25300   {
25301     try {
25302       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25303     } catch (std::out_of_range& e) {
25304       {
25305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25306       };
25307     } catch (std::exception& e) {
25308       {
25309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25310       };
25311     } catch (Dali::DaliException e) {
25312       {
25313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25314       };
25315     } catch (...) {
25316       {
25317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25318       };
25319     }
25320   }
25321
25322   jresult = new Dali::Texture((const Dali::Texture &)result);
25323   return jresult;
25324 }
25325
25326
25327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25328   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25329   size_t arg2 ;
25330   Dali::Sampler arg3 ;
25331   Dali::Sampler *argp3 ;
25332
25333   arg1 = (Dali::TextureSet *)jarg1;
25334   arg2 = (size_t)jarg2;
25335   argp3 = (Dali::Sampler *)jarg3;
25336   if (!argp3) {
25337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25338     return ;
25339   }
25340   arg3 = *argp3;
25341   {
25342     try {
25343       (arg1)->SetSampler(arg2,arg3);
25344     } catch (std::out_of_range& e) {
25345       {
25346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25347       };
25348     } catch (std::exception& e) {
25349       {
25350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25351       };
25352     } catch (Dali::DaliException e) {
25353       {
25354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25355       };
25356     } catch (...) {
25357       {
25358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25359       };
25360     }
25361   }
25362
25363 }
25364
25365
25366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25367   void * jresult ;
25368   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25369   size_t arg2 ;
25370   Dali::Sampler result;
25371
25372   arg1 = (Dali::TextureSet *)jarg1;
25373   arg2 = (size_t)jarg2;
25374   {
25375     try {
25376       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25377     } catch (std::out_of_range& e) {
25378       {
25379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25380       };
25381     } catch (std::exception& e) {
25382       {
25383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25384       };
25385     } catch (Dali::DaliException e) {
25386       {
25387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25388       };
25389     } catch (...) {
25390       {
25391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25392       };
25393     }
25394   }
25395
25396   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25397   return jresult;
25398 }
25399
25400
25401 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25402   unsigned long jresult ;
25403   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25404   size_t result;
25405
25406   arg1 = (Dali::TextureSet *)jarg1;
25407   {
25408     try {
25409       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25410     } catch (std::out_of_range& e) {
25411       {
25412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25413       };
25414     } catch (std::exception& e) {
25415       {
25416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25417       };
25418     } catch (Dali::DaliException e) {
25419       {
25420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25421       };
25422     } catch (...) {
25423       {
25424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25425       };
25426     }
25427   }
25428
25429   jresult = (unsigned long)result;
25430   return jresult;
25431 }
25432
25433
25434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25435   void * jresult ;
25436   Dali::Property::Map *arg1 = 0 ;
25437   Dali::PropertyBuffer result;
25438
25439   arg1 = (Dali::Property::Map *)jarg1;
25440   if (!arg1) {
25441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25442     return 0;
25443   }
25444   {
25445     try {
25446       result = Dali::PropertyBuffer::New(*arg1);
25447     } catch (std::out_of_range& e) {
25448       {
25449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25450       };
25451     } catch (std::exception& e) {
25452       {
25453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25454       };
25455     } catch (Dali::DaliException e) {
25456       {
25457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25458       };
25459     } catch (...) {
25460       {
25461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25462       };
25463     }
25464   }
25465
25466   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25467   return jresult;
25468 }
25469
25470
25471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25472   void * jresult ;
25473   Dali::PropertyBuffer *result = 0 ;
25474
25475   {
25476     try {
25477       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25478     } catch (std::out_of_range& e) {
25479       {
25480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25481       };
25482     } catch (std::exception& e) {
25483       {
25484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25485       };
25486     } catch (Dali::DaliException e) {
25487       {
25488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25489       };
25490     } catch (...) {
25491       {
25492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25493       };
25494     }
25495   }
25496
25497   jresult = (void *)result;
25498   return jresult;
25499 }
25500
25501
25502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25503   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25504
25505   arg1 = (Dali::PropertyBuffer *)jarg1;
25506   {
25507     try {
25508       delete arg1;
25509     } catch (std::out_of_range& e) {
25510       {
25511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25512       };
25513     } catch (std::exception& e) {
25514       {
25515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25516       };
25517     } catch (Dali::DaliException e) {
25518       {
25519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25520       };
25521     } catch (...) {
25522       {
25523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25524       };
25525     }
25526   }
25527
25528 }
25529
25530
25531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25532   void * jresult ;
25533   Dali::PropertyBuffer *arg1 = 0 ;
25534   Dali::PropertyBuffer *result = 0 ;
25535
25536   arg1 = (Dali::PropertyBuffer *)jarg1;
25537   if (!arg1) {
25538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25539     return 0;
25540   }
25541   {
25542     try {
25543       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25544     } catch (std::out_of_range& e) {
25545       {
25546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25547       };
25548     } catch (std::exception& e) {
25549       {
25550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25551       };
25552     } catch (Dali::DaliException e) {
25553       {
25554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25555       };
25556     } catch (...) {
25557       {
25558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25559       };
25560     }
25561   }
25562
25563   jresult = (void *)result;
25564   return jresult;
25565 }
25566
25567
25568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25569   void * jresult ;
25570   Dali::BaseHandle arg1 ;
25571   Dali::BaseHandle *argp1 ;
25572   Dali::PropertyBuffer result;
25573
25574   argp1 = (Dali::BaseHandle *)jarg1;
25575   if (!argp1) {
25576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25577     return 0;
25578   }
25579   arg1 = *argp1;
25580   {
25581     try {
25582       result = Dali::PropertyBuffer::DownCast(arg1);
25583     } catch (std::out_of_range& e) {
25584       {
25585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25586       };
25587     } catch (std::exception& e) {
25588       {
25589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25590       };
25591     } catch (Dali::DaliException e) {
25592       {
25593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25594       };
25595     } catch (...) {
25596       {
25597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25598       };
25599     }
25600   }
25601
25602   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25603   return jresult;
25604 }
25605
25606
25607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25608   void * jresult ;
25609   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25610   Dali::PropertyBuffer *arg2 = 0 ;
25611   Dali::PropertyBuffer *result = 0 ;
25612
25613   arg1 = (Dali::PropertyBuffer *)jarg1;
25614   arg2 = (Dali::PropertyBuffer *)jarg2;
25615   if (!arg2) {
25616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25617     return 0;
25618   }
25619   {
25620     try {
25621       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25622     } catch (std::out_of_range& e) {
25623       {
25624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25625       };
25626     } catch (std::exception& e) {
25627       {
25628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25629       };
25630     } catch (Dali::DaliException e) {
25631       {
25632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25633       };
25634     } catch (...) {
25635       {
25636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25637       };
25638     }
25639   }
25640
25641   jresult = (void *)result;
25642   return jresult;
25643 }
25644
25645
25646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25647   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25648   void *arg2 = (void *) 0 ;
25649   std::size_t arg3 ;
25650
25651   arg1 = (Dali::PropertyBuffer *)jarg1;
25652   arg2 = jarg2;
25653   arg3 = (std::size_t)jarg3;
25654   {
25655     try {
25656       (arg1)->SetData((void const *)arg2,arg3);
25657     } catch (std::out_of_range& e) {
25658       {
25659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25660       };
25661     } catch (std::exception& e) {
25662       {
25663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25664       };
25665     } catch (Dali::DaliException e) {
25666       {
25667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25668       };
25669     } catch (...) {
25670       {
25671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25672       };
25673     }
25674   }
25675
25676 }
25677
25678
25679 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25680   unsigned long jresult ;
25681   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25682   std::size_t result;
25683
25684   arg1 = (Dali::PropertyBuffer *)jarg1;
25685   {
25686     try {
25687       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25688     } catch (std::out_of_range& e) {
25689       {
25690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25691       };
25692     } catch (std::exception& e) {
25693       {
25694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25695       };
25696     } catch (Dali::DaliException e) {
25697       {
25698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25699       };
25700     } catch (...) {
25701       {
25702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25703       };
25704     }
25705   }
25706
25707   jresult = (unsigned long)result;
25708   return jresult;
25709 }
25710
25711
25712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25713   void * jresult ;
25714   Dali::Geometry result;
25715
25716   {
25717     try {
25718       result = Dali::Geometry::New();
25719     } catch (std::out_of_range& e) {
25720       {
25721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25722       };
25723     } catch (std::exception& e) {
25724       {
25725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25726       };
25727     } catch (Dali::DaliException e) {
25728       {
25729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25730       };
25731     } catch (...) {
25732       {
25733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25734       };
25735     }
25736   }
25737
25738   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25739   return jresult;
25740 }
25741
25742
25743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25744   void * jresult ;
25745   Dali::Geometry *result = 0 ;
25746
25747   {
25748     try {
25749       result = (Dali::Geometry *)new Dali::Geometry();
25750     } catch (std::out_of_range& e) {
25751       {
25752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25753       };
25754     } catch (std::exception& e) {
25755       {
25756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25757       };
25758     } catch (Dali::DaliException e) {
25759       {
25760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25761       };
25762     } catch (...) {
25763       {
25764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25765       };
25766     }
25767   }
25768
25769   jresult = (void *)result;
25770   return jresult;
25771 }
25772
25773
25774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25775   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25776
25777   arg1 = (Dali::Geometry *)jarg1;
25778   {
25779     try {
25780       delete arg1;
25781     } catch (std::out_of_range& e) {
25782       {
25783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25784       };
25785     } catch (std::exception& e) {
25786       {
25787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25788       };
25789     } catch (Dali::DaliException e) {
25790       {
25791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25792       };
25793     } catch (...) {
25794       {
25795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25796       };
25797     }
25798   }
25799
25800 }
25801
25802
25803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25804   void * jresult ;
25805   Dali::Geometry *arg1 = 0 ;
25806   Dali::Geometry *result = 0 ;
25807
25808   arg1 = (Dali::Geometry *)jarg1;
25809   if (!arg1) {
25810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25811     return 0;
25812   }
25813   {
25814     try {
25815       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25816     } catch (std::out_of_range& e) {
25817       {
25818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25819       };
25820     } catch (std::exception& e) {
25821       {
25822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25823       };
25824     } catch (Dali::DaliException e) {
25825       {
25826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25827       };
25828     } catch (...) {
25829       {
25830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25831       };
25832     }
25833   }
25834
25835   jresult = (void *)result;
25836   return jresult;
25837 }
25838
25839
25840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25841   void * jresult ;
25842   Dali::BaseHandle arg1 ;
25843   Dali::BaseHandle *argp1 ;
25844   Dali::Geometry result;
25845
25846   argp1 = (Dali::BaseHandle *)jarg1;
25847   if (!argp1) {
25848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25849     return 0;
25850   }
25851   arg1 = *argp1;
25852   {
25853     try {
25854       result = Dali::Geometry::DownCast(arg1);
25855     } catch (std::out_of_range& e) {
25856       {
25857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25858       };
25859     } catch (std::exception& e) {
25860       {
25861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25862       };
25863     } catch (Dali::DaliException e) {
25864       {
25865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25866       };
25867     } catch (...) {
25868       {
25869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25870       };
25871     }
25872   }
25873
25874   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25875   return jresult;
25876 }
25877
25878
25879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25880   void * jresult ;
25881   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25882   Dali::Geometry *arg2 = 0 ;
25883   Dali::Geometry *result = 0 ;
25884
25885   arg1 = (Dali::Geometry *)jarg1;
25886   arg2 = (Dali::Geometry *)jarg2;
25887   if (!arg2) {
25888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25889     return 0;
25890   }
25891   {
25892     try {
25893       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25894     } catch (std::out_of_range& e) {
25895       {
25896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25897       };
25898     } catch (std::exception& e) {
25899       {
25900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25901       };
25902     } catch (Dali::DaliException e) {
25903       {
25904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25905       };
25906     } catch (...) {
25907       {
25908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25909       };
25910     }
25911   }
25912
25913   jresult = (void *)result;
25914   return jresult;
25915 }
25916
25917
25918 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25919   unsigned long jresult ;
25920   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25921   Dali::PropertyBuffer *arg2 = 0 ;
25922   std::size_t result;
25923
25924   arg1 = (Dali::Geometry *)jarg1;
25925   arg2 = (Dali::PropertyBuffer *)jarg2;
25926   if (!arg2) {
25927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25928     return 0;
25929   }
25930   {
25931     try {
25932       result = (arg1)->AddVertexBuffer(*arg2);
25933     } catch (std::out_of_range& e) {
25934       {
25935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25936       };
25937     } catch (std::exception& e) {
25938       {
25939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25940       };
25941     } catch (Dali::DaliException e) {
25942       {
25943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25944       };
25945     } catch (...) {
25946       {
25947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25948       };
25949     }
25950   }
25951
25952   jresult = (unsigned long)result;
25953   return jresult;
25954 }
25955
25956
25957 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25958   unsigned long jresult ;
25959   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25960   std::size_t result;
25961
25962   arg1 = (Dali::Geometry *)jarg1;
25963   {
25964     try {
25965       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25966     } catch (std::out_of_range& e) {
25967       {
25968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25969       };
25970     } catch (std::exception& e) {
25971       {
25972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25973       };
25974     } catch (Dali::DaliException e) {
25975       {
25976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25977       };
25978     } catch (...) {
25979       {
25980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25981       };
25982     }
25983   }
25984
25985   jresult = (unsigned long)result;
25986   return jresult;
25987 }
25988
25989
25990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25991   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25992   std::size_t arg2 ;
25993
25994   arg1 = (Dali::Geometry *)jarg1;
25995   arg2 = (std::size_t)jarg2;
25996   {
25997     try {
25998       (arg1)->RemoveVertexBuffer(arg2);
25999     } catch (std::out_of_range& e) {
26000       {
26001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26002       };
26003     } catch (std::exception& e) {
26004       {
26005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26006       };
26007     } catch (Dali::DaliException e) {
26008       {
26009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26010       };
26011     } catch (...) {
26012       {
26013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26014       };
26015     }
26016   }
26017
26018 }
26019
26020
26021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26022   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26023   unsigned short *arg2 = (unsigned short *) 0 ;
26024   size_t arg3 ;
26025
26026   arg1 = (Dali::Geometry *)jarg1;
26027   arg2 = jarg2;
26028   arg3 = (size_t)jarg3;
26029   {
26030     try {
26031       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26032     } catch (std::out_of_range& e) {
26033       {
26034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26035       };
26036     } catch (std::exception& e) {
26037       {
26038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26039       };
26040     } catch (Dali::DaliException e) {
26041       {
26042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26043       };
26044     } catch (...) {
26045       {
26046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26047       };
26048     }
26049   }
26050
26051
26052
26053 }
26054
26055
26056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26057   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26058   Dali::Geometry::Type arg2 ;
26059
26060   arg1 = (Dali::Geometry *)jarg1;
26061   arg2 = (Dali::Geometry::Type)jarg2;
26062   {
26063     try {
26064       (arg1)->SetType(arg2);
26065     } catch (std::out_of_range& e) {
26066       {
26067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26068       };
26069     } catch (std::exception& e) {
26070       {
26071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26072       };
26073     } catch (Dali::DaliException e) {
26074       {
26075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26076       };
26077     } catch (...) {
26078       {
26079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26080       };
26081     }
26082   }
26083
26084 }
26085
26086
26087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26088   int jresult ;
26089   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26090   Dali::Geometry::Type result;
26091
26092   arg1 = (Dali::Geometry *)jarg1;
26093   {
26094     try {
26095       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26096     } catch (std::out_of_range& e) {
26097       {
26098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26099       };
26100     } catch (std::exception& e) {
26101       {
26102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26103       };
26104     } catch (Dali::DaliException e) {
26105       {
26106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26107       };
26108     } catch (...) {
26109       {
26110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26111       };
26112     }
26113   }
26114
26115   jresult = (int)result;
26116   return jresult;
26117 }
26118
26119
26120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26121   void * jresult ;
26122   Dali::Shader::Hint *result = 0 ;
26123
26124   {
26125     try {
26126       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26127     } catch (std::out_of_range& e) {
26128       {
26129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26130       };
26131     } catch (std::exception& e) {
26132       {
26133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26134       };
26135     } catch (Dali::DaliException e) {
26136       {
26137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26138       };
26139     } catch (...) {
26140       {
26141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26142       };
26143     }
26144   }
26145
26146   jresult = (void *)result;
26147   return jresult;
26148 }
26149
26150
26151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26152   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26153
26154   arg1 = (Dali::Shader::Hint *)jarg1;
26155   {
26156     try {
26157       delete arg1;
26158     } catch (std::out_of_range& e) {
26159       {
26160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26161       };
26162     } catch (std::exception& e) {
26163       {
26164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26165       };
26166     } catch (Dali::DaliException e) {
26167       {
26168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26169       };
26170     } catch (...) {
26171       {
26172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26173       };
26174     }
26175   }
26176
26177 }
26178
26179
26180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26181   int jresult ;
26182   int result;
26183
26184   result = (int)Dali::Shader::Property::PROGRAM;
26185   jresult = (int)result;
26186   return jresult;
26187 }
26188
26189
26190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26191   void * jresult ;
26192   Dali::Shader::Property *result = 0 ;
26193
26194   {
26195     try {
26196       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26197     } catch (std::out_of_range& e) {
26198       {
26199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26200       };
26201     } catch (std::exception& e) {
26202       {
26203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26204       };
26205     } catch (Dali::DaliException e) {
26206       {
26207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26208       };
26209     } catch (...) {
26210       {
26211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26212       };
26213     }
26214   }
26215
26216   jresult = (void *)result;
26217   return jresult;
26218 }
26219
26220
26221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26222   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26223
26224   arg1 = (Dali::Shader::Property *)jarg1;
26225   {
26226     try {
26227       delete arg1;
26228     } catch (std::out_of_range& e) {
26229       {
26230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26231       };
26232     } catch (std::exception& e) {
26233       {
26234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26235       };
26236     } catch (Dali::DaliException e) {
26237       {
26238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26239       };
26240     } catch (...) {
26241       {
26242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26243       };
26244     }
26245   }
26246
26247 }
26248
26249
26250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26251   void * jresult ;
26252   std::string *arg1 = 0 ;
26253   std::string *arg2 = 0 ;
26254   Dali::Shader::Hint::Value arg3 ;
26255   Dali::Shader result;
26256
26257   if (!jarg1) {
26258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26259     return 0;
26260   }
26261   std::string arg1_str(jarg1);
26262   arg1 = &arg1_str;
26263   if (!jarg2) {
26264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26265     return 0;
26266   }
26267   std::string arg2_str(jarg2);
26268   arg2 = &arg2_str;
26269   arg3 = (Dali::Shader::Hint::Value)jarg3;
26270   {
26271     try {
26272       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26273     } catch (std::out_of_range& e) {
26274       {
26275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26276       };
26277     } catch (std::exception& e) {
26278       {
26279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26280       };
26281     } catch (Dali::DaliException e) {
26282       {
26283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26284       };
26285     } catch (...) {
26286       {
26287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26288       };
26289     }
26290   }
26291
26292   jresult = new Dali::Shader((const Dali::Shader &)result);
26293
26294   //argout typemap for const std::string&
26295
26296
26297   //argout typemap for const std::string&
26298
26299   return jresult;
26300 }
26301
26302
26303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26304   void * jresult ;
26305   std::string *arg1 = 0 ;
26306   std::string *arg2 = 0 ;
26307   Dali::Shader result;
26308
26309   if (!jarg1) {
26310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26311     return 0;
26312   }
26313   std::string arg1_str(jarg1);
26314   arg1 = &arg1_str;
26315   if (!jarg2) {
26316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26317     return 0;
26318   }
26319   std::string arg2_str(jarg2);
26320   arg2 = &arg2_str;
26321   {
26322     try {
26323       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26324     } catch (std::out_of_range& e) {
26325       {
26326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26327       };
26328     } catch (std::exception& e) {
26329       {
26330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26331       };
26332     } catch (Dali::DaliException e) {
26333       {
26334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26335       };
26336     } catch (...) {
26337       {
26338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26339       };
26340     }
26341   }
26342
26343   jresult = new Dali::Shader((const Dali::Shader &)result);
26344
26345   //argout typemap for const std::string&
26346
26347
26348   //argout typemap for const std::string&
26349
26350   return jresult;
26351 }
26352
26353
26354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26355   void * jresult ;
26356   Dali::Shader *result = 0 ;
26357
26358   {
26359     try {
26360       result = (Dali::Shader *)new Dali::Shader();
26361     } catch (std::out_of_range& e) {
26362       {
26363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26364       };
26365     } catch (std::exception& e) {
26366       {
26367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26368       };
26369     } catch (Dali::DaliException e) {
26370       {
26371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26372       };
26373     } catch (...) {
26374       {
26375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26376       };
26377     }
26378   }
26379
26380   jresult = (void *)result;
26381   return jresult;
26382 }
26383
26384
26385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26386   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26387
26388   arg1 = (Dali::Shader *)jarg1;
26389   {
26390     try {
26391       delete arg1;
26392     } catch (std::out_of_range& e) {
26393       {
26394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26395       };
26396     } catch (std::exception& e) {
26397       {
26398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26399       };
26400     } catch (Dali::DaliException e) {
26401       {
26402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26403       };
26404     } catch (...) {
26405       {
26406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26407       };
26408     }
26409   }
26410
26411 }
26412
26413
26414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26415   void * jresult ;
26416   Dali::Shader *arg1 = 0 ;
26417   Dali::Shader *result = 0 ;
26418
26419   arg1 = (Dali::Shader *)jarg1;
26420   if (!arg1) {
26421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26422     return 0;
26423   }
26424   {
26425     try {
26426       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26427     } catch (std::out_of_range& e) {
26428       {
26429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26430       };
26431     } catch (std::exception& e) {
26432       {
26433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26434       };
26435     } catch (Dali::DaliException e) {
26436       {
26437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26438       };
26439     } catch (...) {
26440       {
26441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26442       };
26443     }
26444   }
26445
26446   jresult = (void *)result;
26447   return jresult;
26448 }
26449
26450
26451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26452   void * jresult ;
26453   Dali::BaseHandle arg1 ;
26454   Dali::BaseHandle *argp1 ;
26455   Dali::Shader result;
26456
26457   argp1 = (Dali::BaseHandle *)jarg1;
26458   if (!argp1) {
26459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26460     return 0;
26461   }
26462   arg1 = *argp1;
26463   {
26464     try {
26465       result = Dali::Shader::DownCast(arg1);
26466     } catch (std::out_of_range& e) {
26467       {
26468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26469       };
26470     } catch (std::exception& e) {
26471       {
26472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26473       };
26474     } catch (Dali::DaliException e) {
26475       {
26476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26477       };
26478     } catch (...) {
26479       {
26480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26481       };
26482     }
26483   }
26484
26485   jresult = new Dali::Shader((const Dali::Shader &)result);
26486   return jresult;
26487 }
26488
26489
26490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26491   void * jresult ;
26492   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26493   Dali::Shader *arg2 = 0 ;
26494   Dali::Shader *result = 0 ;
26495
26496   arg1 = (Dali::Shader *)jarg1;
26497   arg2 = (Dali::Shader *)jarg2;
26498   if (!arg2) {
26499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26500     return 0;
26501   }
26502   {
26503     try {
26504       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26505     } catch (std::out_of_range& e) {
26506       {
26507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26508       };
26509     } catch (std::exception& e) {
26510       {
26511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26512       };
26513     } catch (Dali::DaliException e) {
26514       {
26515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26516       };
26517     } catch (...) {
26518       {
26519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26520       };
26521     }
26522   }
26523
26524   jresult = (void *)result;
26525   return jresult;
26526 }
26527
26528
26529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26530   int jresult ;
26531   int result;
26532
26533   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26534   jresult = (int)result;
26535   return jresult;
26536 }
26537
26538
26539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26540   int jresult ;
26541   int result;
26542
26543   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26544   jresult = (int)result;
26545   return jresult;
26546 }
26547
26548
26549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26550   int jresult ;
26551   int result;
26552
26553   result = (int)Dali::Renderer::Property::BLEND_MODE;
26554   jresult = (int)result;
26555   return jresult;
26556 }
26557
26558
26559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26560   int jresult ;
26561   int result;
26562
26563   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26564   jresult = (int)result;
26565   return jresult;
26566 }
26567
26568
26569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26570   int jresult ;
26571   int result;
26572
26573   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26574   jresult = (int)result;
26575   return jresult;
26576 }
26577
26578
26579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26580   int jresult ;
26581   int result;
26582
26583   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26584   jresult = (int)result;
26585   return jresult;
26586 }
26587
26588
26589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26590   int jresult ;
26591   int result;
26592
26593   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26594   jresult = (int)result;
26595   return jresult;
26596 }
26597
26598
26599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26600   int jresult ;
26601   int result;
26602
26603   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26604   jresult = (int)result;
26605   return jresult;
26606 }
26607
26608
26609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26610   int jresult ;
26611   int result;
26612
26613   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26614   jresult = (int)result;
26615   return jresult;
26616 }
26617
26618
26619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26620   int jresult ;
26621   int result;
26622
26623   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26624   jresult = (int)result;
26625   return jresult;
26626 }
26627
26628
26629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26630   int jresult ;
26631   int result;
26632
26633   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26634   jresult = (int)result;
26635   return jresult;
26636 }
26637
26638
26639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26640   int jresult ;
26641   int result;
26642
26643   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26644   jresult = (int)result;
26645   return jresult;
26646 }
26647
26648
26649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26650   int jresult ;
26651   int result;
26652
26653   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26654   jresult = (int)result;
26655   return jresult;
26656 }
26657
26658
26659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26660   int jresult ;
26661   int result;
26662
26663   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26664   jresult = (int)result;
26665   return jresult;
26666 }
26667
26668
26669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26670   int jresult ;
26671   int result;
26672
26673   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26674   jresult = (int)result;
26675   return jresult;
26676 }
26677
26678
26679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26680   int jresult ;
26681   int result;
26682
26683   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26684   jresult = (int)result;
26685   return jresult;
26686 }
26687
26688
26689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26690   int jresult ;
26691   int result;
26692
26693   result = (int)Dali::Renderer::Property::RENDER_MODE;
26694   jresult = (int)result;
26695   return jresult;
26696 }
26697
26698
26699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26700   int jresult ;
26701   int result;
26702
26703   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26704   jresult = (int)result;
26705   return jresult;
26706 }
26707
26708
26709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26710   int jresult ;
26711   int result;
26712
26713   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26714   jresult = (int)result;
26715   return jresult;
26716 }
26717
26718
26719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26720   int jresult ;
26721   int result;
26722
26723   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26724   jresult = (int)result;
26725   return jresult;
26726 }
26727
26728
26729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26730   int jresult ;
26731   int result;
26732
26733   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26734   jresult = (int)result;
26735   return jresult;
26736 }
26737
26738
26739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26740   int jresult ;
26741   int result;
26742
26743   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26744   jresult = (int)result;
26745   return jresult;
26746 }
26747
26748
26749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26750   int jresult ;
26751   int result;
26752
26753   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26754   jresult = (int)result;
26755   return jresult;
26756 }
26757
26758
26759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26760   int jresult ;
26761   int result;
26762
26763   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26764   jresult = (int)result;
26765   return jresult;
26766 }
26767
26768
26769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26770   void * jresult ;
26771   Dali::Renderer::Property *result = 0 ;
26772
26773   {
26774     try {
26775       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26776     } catch (std::out_of_range& e) {
26777       {
26778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26779       };
26780     } catch (std::exception& e) {
26781       {
26782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26783       };
26784     } catch (Dali::DaliException e) {
26785       {
26786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26787       };
26788     } catch (...) {
26789       {
26790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26791       };
26792     }
26793   }
26794
26795   jresult = (void *)result;
26796   return jresult;
26797 }
26798
26799
26800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26801   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26802
26803   arg1 = (Dali::Renderer::Property *)jarg1;
26804   {
26805     try {
26806       delete arg1;
26807     } catch (std::out_of_range& e) {
26808       {
26809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26810       };
26811     } catch (std::exception& e) {
26812       {
26813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26814       };
26815     } catch (Dali::DaliException e) {
26816       {
26817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26818       };
26819     } catch (...) {
26820       {
26821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26822       };
26823     }
26824   }
26825
26826 }
26827
26828
26829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26830   void * jresult ;
26831   Dali::Geometry *arg1 = 0 ;
26832   Dali::Shader *arg2 = 0 ;
26833   Dali::Renderer result;
26834
26835   arg1 = (Dali::Geometry *)jarg1;
26836   if (!arg1) {
26837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26838     return 0;
26839   }
26840   arg2 = (Dali::Shader *)jarg2;
26841   if (!arg2) {
26842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26843     return 0;
26844   }
26845   {
26846     try {
26847       result = Dali::Renderer::New(*arg1,*arg2);
26848     } catch (std::out_of_range& e) {
26849       {
26850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26851       };
26852     } catch (std::exception& e) {
26853       {
26854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26855       };
26856     } catch (Dali::DaliException e) {
26857       {
26858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26859       };
26860     } catch (...) {
26861       {
26862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26863       };
26864     }
26865   }
26866
26867   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26868   return jresult;
26869 }
26870
26871
26872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26873   void * jresult ;
26874   Dali::Renderer *result = 0 ;
26875
26876   {
26877     try {
26878       result = (Dali::Renderer *)new Dali::Renderer();
26879     } catch (std::out_of_range& e) {
26880       {
26881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26882       };
26883     } catch (std::exception& e) {
26884       {
26885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26886       };
26887     } catch (Dali::DaliException e) {
26888       {
26889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26890       };
26891     } catch (...) {
26892       {
26893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26894       };
26895     }
26896   }
26897
26898   jresult = (void *)result;
26899   return jresult;
26900 }
26901
26902
26903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26904   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26905
26906   arg1 = (Dali::Renderer *)jarg1;
26907   {
26908     try {
26909       delete arg1;
26910     } catch (std::out_of_range& e) {
26911       {
26912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26913       };
26914     } catch (std::exception& e) {
26915       {
26916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26917       };
26918     } catch (Dali::DaliException e) {
26919       {
26920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26921       };
26922     } catch (...) {
26923       {
26924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26925       };
26926     }
26927   }
26928
26929 }
26930
26931
26932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26933   void * jresult ;
26934   Dali::Renderer *arg1 = 0 ;
26935   Dali::Renderer *result = 0 ;
26936
26937   arg1 = (Dali::Renderer *)jarg1;
26938   if (!arg1) {
26939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26940     return 0;
26941   }
26942   {
26943     try {
26944       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26945     } catch (std::out_of_range& e) {
26946       {
26947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26948       };
26949     } catch (std::exception& e) {
26950       {
26951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26952       };
26953     } catch (Dali::DaliException e) {
26954       {
26955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26956       };
26957     } catch (...) {
26958       {
26959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26960       };
26961     }
26962   }
26963
26964   jresult = (void *)result;
26965   return jresult;
26966 }
26967
26968
26969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26970   void * jresult ;
26971   Dali::BaseHandle arg1 ;
26972   Dali::BaseHandle *argp1 ;
26973   Dali::Renderer result;
26974
26975   argp1 = (Dali::BaseHandle *)jarg1;
26976   if (!argp1) {
26977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26978     return 0;
26979   }
26980   arg1 = *argp1;
26981   {
26982     try {
26983       result = Dali::Renderer::DownCast(arg1);
26984     } catch (std::out_of_range& e) {
26985       {
26986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26987       };
26988     } catch (std::exception& e) {
26989       {
26990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26991       };
26992     } catch (Dali::DaliException e) {
26993       {
26994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26995       };
26996     } catch (...) {
26997       {
26998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26999       };
27000     }
27001   }
27002
27003   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27004   return jresult;
27005 }
27006
27007
27008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27009   void * jresult ;
27010   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27011   Dali::Renderer *arg2 = 0 ;
27012   Dali::Renderer *result = 0 ;
27013
27014   arg1 = (Dali::Renderer *)jarg1;
27015   arg2 = (Dali::Renderer *)jarg2;
27016   if (!arg2) {
27017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27018     return 0;
27019   }
27020   {
27021     try {
27022       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27023     } catch (std::out_of_range& e) {
27024       {
27025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27026       };
27027     } catch (std::exception& e) {
27028       {
27029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27030       };
27031     } catch (Dali::DaliException e) {
27032       {
27033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27034       };
27035     } catch (...) {
27036       {
27037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27038       };
27039     }
27040   }
27041
27042   jresult = (void *)result;
27043   return jresult;
27044 }
27045
27046
27047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27048   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27049   Dali::Geometry *arg2 = 0 ;
27050
27051   arg1 = (Dali::Renderer *)jarg1;
27052   arg2 = (Dali::Geometry *)jarg2;
27053   if (!arg2) {
27054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27055     return ;
27056   }
27057   {
27058     try {
27059       (arg1)->SetGeometry(*arg2);
27060     } catch (std::out_of_range& e) {
27061       {
27062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27063       };
27064     } catch (std::exception& e) {
27065       {
27066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27067       };
27068     } catch (Dali::DaliException e) {
27069       {
27070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27071       };
27072     } catch (...) {
27073       {
27074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27075       };
27076     }
27077   }
27078
27079 }
27080
27081
27082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27083   void * jresult ;
27084   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27085   Dali::Geometry result;
27086
27087   arg1 = (Dali::Renderer *)jarg1;
27088   {
27089     try {
27090       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27091     } catch (std::out_of_range& e) {
27092       {
27093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27094       };
27095     } catch (std::exception& e) {
27096       {
27097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27098       };
27099     } catch (Dali::DaliException e) {
27100       {
27101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27102       };
27103     } catch (...) {
27104       {
27105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27106       };
27107     }
27108   }
27109
27110   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27111   return jresult;
27112 }
27113
27114
27115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27116   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27117   int arg2 ;
27118   int arg3 ;
27119
27120   arg1 = (Dali::Renderer *)jarg1;
27121   arg2 = (int)jarg2;
27122   arg3 = (int)jarg3;
27123   {
27124     try {
27125       (arg1)->SetIndexRange(arg2,arg3);
27126     } catch (std::out_of_range& e) {
27127       {
27128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27129       };
27130     } catch (std::exception& e) {
27131       {
27132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27133       };
27134     } catch (Dali::DaliException e) {
27135       {
27136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27137       };
27138     } catch (...) {
27139       {
27140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27141       };
27142     }
27143   }
27144
27145 }
27146
27147
27148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27149   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27150   Dali::TextureSet *arg2 = 0 ;
27151
27152   arg1 = (Dali::Renderer *)jarg1;
27153   arg2 = (Dali::TextureSet *)jarg2;
27154   if (!arg2) {
27155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27156     return ;
27157   }
27158   {
27159     try {
27160       (arg1)->SetTextures(*arg2);
27161     } catch (std::out_of_range& e) {
27162       {
27163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27164       };
27165     } catch (std::exception& e) {
27166       {
27167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27168       };
27169     } catch (Dali::DaliException e) {
27170       {
27171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27172       };
27173     } catch (...) {
27174       {
27175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27176       };
27177     }
27178   }
27179
27180 }
27181
27182
27183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27184   void * jresult ;
27185   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27186   Dali::TextureSet result;
27187
27188   arg1 = (Dali::Renderer *)jarg1;
27189   {
27190     try {
27191       result = ((Dali::Renderer const *)arg1)->GetTextures();
27192     } catch (std::out_of_range& e) {
27193       {
27194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27195       };
27196     } catch (std::exception& e) {
27197       {
27198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27199       };
27200     } catch (Dali::DaliException e) {
27201       {
27202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27203       };
27204     } catch (...) {
27205       {
27206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27207       };
27208     }
27209   }
27210
27211   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27212   return jresult;
27213 }
27214
27215
27216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27217   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27218   Dali::Shader *arg2 = 0 ;
27219
27220   arg1 = (Dali::Renderer *)jarg1;
27221   arg2 = (Dali::Shader *)jarg2;
27222   if (!arg2) {
27223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27224     return ;
27225   }
27226   {
27227     try {
27228       (arg1)->SetShader(*arg2);
27229     } catch (std::out_of_range& e) {
27230       {
27231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27232       };
27233     } catch (std::exception& e) {
27234       {
27235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27236       };
27237     } catch (Dali::DaliException e) {
27238       {
27239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27240       };
27241     } catch (...) {
27242       {
27243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27244       };
27245     }
27246   }
27247
27248 }
27249
27250
27251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27252   void * jresult ;
27253   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27254   Dali::Shader result;
27255
27256   arg1 = (Dali::Renderer *)jarg1;
27257   {
27258     try {
27259       result = ((Dali::Renderer const *)arg1)->GetShader();
27260     } catch (std::out_of_range& e) {
27261       {
27262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27263       };
27264     } catch (std::exception& e) {
27265       {
27266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27267       };
27268     } catch (Dali::DaliException e) {
27269       {
27270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27271       };
27272     } catch (...) {
27273       {
27274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27275       };
27276     }
27277   }
27278
27279   jresult = new Dali::Shader((const Dali::Shader &)result);
27280   return jresult;
27281 }
27282
27283
27284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27285   void * jresult ;
27286   Dali::FrameBuffer::Attachment *result = 0 ;
27287
27288   {
27289     try {
27290       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27291     } catch (std::out_of_range& e) {
27292       {
27293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27294       };
27295     } catch (std::exception& e) {
27296       {
27297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27298       };
27299     } catch (Dali::DaliException e) {
27300       {
27301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27302       };
27303     } catch (...) {
27304       {
27305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27306       };
27307     }
27308   }
27309
27310   jresult = (void *)result;
27311   return jresult;
27312 }
27313
27314
27315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27316   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27317
27318   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27319   {
27320     try {
27321       delete arg1;
27322     } catch (std::out_of_range& e) {
27323       {
27324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27325       };
27326     } catch (std::exception& e) {
27327       {
27328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27329       };
27330     } catch (Dali::DaliException e) {
27331       {
27332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27333       };
27334     } catch (...) {
27335       {
27336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27337       };
27338     }
27339   }
27340
27341 }
27342
27343
27344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27345   void * jresult ;
27346   unsigned int arg1 ;
27347   unsigned int arg2 ;
27348   unsigned int arg3 ;
27349   Dali::FrameBuffer result;
27350
27351   arg1 = (unsigned int)jarg1;
27352   arg2 = (unsigned int)jarg2;
27353   arg3 = (unsigned int)jarg3;
27354   {
27355     try {
27356       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27357     } catch (std::out_of_range& e) {
27358       {
27359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27360       };
27361     } catch (std::exception& e) {
27362       {
27363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27364       };
27365     } catch (Dali::DaliException e) {
27366       {
27367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27368       };
27369     } catch (...) {
27370       {
27371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27372       };
27373     }
27374   }
27375
27376   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27377   return jresult;
27378 }
27379
27380
27381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27382   void * jresult ;
27383   Dali::FrameBuffer *result = 0 ;
27384
27385   {
27386     try {
27387       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27388     } catch (std::out_of_range& e) {
27389       {
27390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27391       };
27392     } catch (std::exception& e) {
27393       {
27394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27395       };
27396     } catch (Dali::DaliException e) {
27397       {
27398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27399       };
27400     } catch (...) {
27401       {
27402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27403       };
27404     }
27405   }
27406
27407   jresult = (void *)result;
27408   return jresult;
27409 }
27410
27411
27412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27413   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27414
27415   arg1 = (Dali::FrameBuffer *)jarg1;
27416   {
27417     try {
27418       delete arg1;
27419     } catch (std::out_of_range& e) {
27420       {
27421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27422       };
27423     } catch (std::exception& e) {
27424       {
27425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27426       };
27427     } catch (Dali::DaliException e) {
27428       {
27429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27430       };
27431     } catch (...) {
27432       {
27433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27434       };
27435     }
27436   }
27437
27438 }
27439
27440
27441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27442   void * jresult ;
27443   Dali::FrameBuffer *arg1 = 0 ;
27444   Dali::FrameBuffer *result = 0 ;
27445
27446   arg1 = (Dali::FrameBuffer *)jarg1;
27447   if (!arg1) {
27448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27449     return 0;
27450   }
27451   {
27452     try {
27453       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27454     } catch (std::out_of_range& e) {
27455       {
27456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27457       };
27458     } catch (std::exception& e) {
27459       {
27460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27461       };
27462     } catch (Dali::DaliException e) {
27463       {
27464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27465       };
27466     } catch (...) {
27467       {
27468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27469       };
27470     }
27471   }
27472
27473   jresult = (void *)result;
27474   return jresult;
27475 }
27476
27477
27478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27479   void * jresult ;
27480   Dali::BaseHandle arg1 ;
27481   Dali::BaseHandle *argp1 ;
27482   Dali::FrameBuffer result;
27483
27484   argp1 = (Dali::BaseHandle *)jarg1;
27485   if (!argp1) {
27486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27487     return 0;
27488   }
27489   arg1 = *argp1;
27490   {
27491     try {
27492       result = Dali::FrameBuffer::DownCast(arg1);
27493     } catch (std::out_of_range& e) {
27494       {
27495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27496       };
27497     } catch (std::exception& e) {
27498       {
27499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27500       };
27501     } catch (Dali::DaliException e) {
27502       {
27503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27504       };
27505     } catch (...) {
27506       {
27507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27508       };
27509     }
27510   }
27511
27512   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27513   return jresult;
27514 }
27515
27516
27517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27518   void * jresult ;
27519   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27520   Dali::FrameBuffer *arg2 = 0 ;
27521   Dali::FrameBuffer *result = 0 ;
27522
27523   arg1 = (Dali::FrameBuffer *)jarg1;
27524   arg2 = (Dali::FrameBuffer *)jarg2;
27525   if (!arg2) {
27526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27527     return 0;
27528   }
27529   {
27530     try {
27531       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27532     } catch (std::out_of_range& e) {
27533       {
27534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27535       };
27536     } catch (std::exception& e) {
27537       {
27538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27539       };
27540     } catch (Dali::DaliException e) {
27541       {
27542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27543       };
27544     } catch (...) {
27545       {
27546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27547       };
27548     }
27549   }
27550
27551   jresult = (void *)result;
27552   return jresult;
27553 }
27554
27555
27556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27557   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27558   Dali::Texture *arg2 = 0 ;
27559
27560   arg1 = (Dali::FrameBuffer *)jarg1;
27561   arg2 = (Dali::Texture *)jarg2;
27562   if (!arg2) {
27563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27564     return ;
27565   }
27566   {
27567     try {
27568       (arg1)->AttachColorTexture(*arg2);
27569     } catch (std::out_of_range& e) {
27570       {
27571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27572       };
27573     } catch (std::exception& e) {
27574       {
27575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27576       };
27577     } catch (Dali::DaliException e) {
27578       {
27579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27580       };
27581     } catch (...) {
27582       {
27583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27584       };
27585     }
27586   }
27587
27588 }
27589
27590
27591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27592   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27593   Dali::Texture *arg2 = 0 ;
27594   unsigned int arg3 ;
27595   unsigned int arg4 ;
27596
27597   arg1 = (Dali::FrameBuffer *)jarg1;
27598   arg2 = (Dali::Texture *)jarg2;
27599   if (!arg2) {
27600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27601     return ;
27602   }
27603   arg3 = (unsigned int)jarg3;
27604   arg4 = (unsigned int)jarg4;
27605   {
27606     try {
27607       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27608     } catch (std::out_of_range& e) {
27609       {
27610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27611       };
27612     } catch (std::exception& e) {
27613       {
27614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27615       };
27616     } catch (Dali::DaliException e) {
27617       {
27618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27619       };
27620     } catch (...) {
27621       {
27622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27623       };
27624     }
27625   }
27626
27627 }
27628
27629
27630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27631   void * jresult ;
27632   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27633   Dali::Texture result;
27634
27635   arg1 = (Dali::FrameBuffer *)jarg1;
27636   {
27637     try {
27638       result = (arg1)->GetColorTexture();
27639     } catch (std::out_of_range& e) {
27640       {
27641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27642       };
27643     } catch (std::exception& e) {
27644       {
27645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27646       };
27647     } catch (Dali::DaliException e) {
27648       {
27649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27650       };
27651     } catch (...) {
27652       {
27653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27654       };
27655     }
27656   }
27657
27658   jresult = new Dali::Texture((const Dali::Texture &)result);
27659   return jresult;
27660 }
27661
27662
27663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27664   void * jresult ;
27665   Dali::RenderTaskList *result = 0 ;
27666
27667   {
27668     try {
27669       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27670     } catch (std::out_of_range& e) {
27671       {
27672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27673       };
27674     } catch (std::exception& e) {
27675       {
27676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27677       };
27678     } catch (Dali::DaliException e) {
27679       {
27680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27681       };
27682     } catch (...) {
27683       {
27684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27685       };
27686     }
27687   }
27688
27689   jresult = (void *)result;
27690   return jresult;
27691 }
27692
27693
27694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27695   void * jresult ;
27696   Dali::BaseHandle arg1 ;
27697   Dali::BaseHandle *argp1 ;
27698   Dali::RenderTaskList result;
27699
27700   argp1 = (Dali::BaseHandle *)jarg1;
27701   if (!argp1) {
27702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27703     return 0;
27704   }
27705   arg1 = *argp1;
27706   {
27707     try {
27708       result = Dali::RenderTaskList::DownCast(arg1);
27709     } catch (std::out_of_range& e) {
27710       {
27711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27712       };
27713     } catch (std::exception& e) {
27714       {
27715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27716       };
27717     } catch (Dali::DaliException e) {
27718       {
27719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27720       };
27721     } catch (...) {
27722       {
27723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27724       };
27725     }
27726   }
27727
27728   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27729   return jresult;
27730 }
27731
27732
27733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27734   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27735
27736   arg1 = (Dali::RenderTaskList *)jarg1;
27737   {
27738     try {
27739       delete arg1;
27740     } catch (std::out_of_range& e) {
27741       {
27742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27743       };
27744     } catch (std::exception& e) {
27745       {
27746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27747       };
27748     } catch (Dali::DaliException e) {
27749       {
27750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27751       };
27752     } catch (...) {
27753       {
27754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27755       };
27756     }
27757   }
27758
27759 }
27760
27761
27762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27763   void * jresult ;
27764   Dali::RenderTaskList *arg1 = 0 ;
27765   Dali::RenderTaskList *result = 0 ;
27766
27767   arg1 = (Dali::RenderTaskList *)jarg1;
27768   if (!arg1) {
27769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27770     return 0;
27771   }
27772   {
27773     try {
27774       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27775     } catch (std::out_of_range& e) {
27776       {
27777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27778       };
27779     } catch (std::exception& e) {
27780       {
27781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27782       };
27783     } catch (Dali::DaliException e) {
27784       {
27785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27786       };
27787     } catch (...) {
27788       {
27789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27790       };
27791     }
27792   }
27793
27794   jresult = (void *)result;
27795   return jresult;
27796 }
27797
27798
27799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27800   void * jresult ;
27801   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27802   Dali::RenderTaskList *arg2 = 0 ;
27803   Dali::RenderTaskList *result = 0 ;
27804
27805   arg1 = (Dali::RenderTaskList *)jarg1;
27806   arg2 = (Dali::RenderTaskList *)jarg2;
27807   if (!arg2) {
27808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27809     return 0;
27810   }
27811   {
27812     try {
27813       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27814     } catch (std::out_of_range& e) {
27815       {
27816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27817       };
27818     } catch (std::exception& e) {
27819       {
27820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27821       };
27822     } catch (Dali::DaliException e) {
27823       {
27824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27825       };
27826     } catch (...) {
27827       {
27828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27829       };
27830     }
27831   }
27832
27833   jresult = (void *)result;
27834   return jresult;
27835 }
27836
27837
27838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27839   void * jresult ;
27840   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27841   Dali::RenderTask result;
27842
27843   arg1 = (Dali::RenderTaskList *)jarg1;
27844   {
27845     try {
27846       result = (arg1)->CreateTask();
27847     } catch (std::out_of_range& e) {
27848       {
27849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27850       };
27851     } catch (std::exception& e) {
27852       {
27853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27854       };
27855     } catch (Dali::DaliException e) {
27856       {
27857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27858       };
27859     } catch (...) {
27860       {
27861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27862       };
27863     }
27864   }
27865
27866   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27867   return jresult;
27868 }
27869
27870
27871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27872   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27873   Dali::RenderTask arg2 ;
27874   Dali::RenderTask *argp2 ;
27875
27876   arg1 = (Dali::RenderTaskList *)jarg1;
27877   argp2 = (Dali::RenderTask *)jarg2;
27878   if (!argp2) {
27879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27880     return ;
27881   }
27882   arg2 = *argp2;
27883   {
27884     try {
27885       (arg1)->RemoveTask(arg2);
27886     } catch (std::out_of_range& e) {
27887       {
27888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27889       };
27890     } catch (std::exception& e) {
27891       {
27892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27893       };
27894     } catch (Dali::DaliException e) {
27895       {
27896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27897       };
27898     } catch (...) {
27899       {
27900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27901       };
27902     }
27903   }
27904
27905 }
27906
27907
27908 //// ===============================================end part 1 =================
27909
27910 //// ========================= part 2 ===============================
27911
27912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27913   unsigned int jresult ;
27914   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27915   unsigned int result;
27916
27917   arg1 = (Dali::RenderTaskList *)jarg1;
27918   {
27919     try {
27920       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27921     } catch (std::out_of_range& e) {
27922       {
27923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27924       };
27925     } catch (std::exception& e) {
27926       {
27927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27928       };
27929     } catch (Dali::DaliException e) {
27930       {
27931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27932       };
27933     } catch (...) {
27934       {
27935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27936       };
27937     }
27938   }
27939
27940   jresult = result;
27941   return jresult;
27942 }
27943
27944
27945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27946   void * jresult ;
27947   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27948   unsigned int arg2 ;
27949   Dali::RenderTask result;
27950
27951   arg1 = (Dali::RenderTaskList *)jarg1;
27952   arg2 = (unsigned int)jarg2;
27953   {
27954     try {
27955       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27956     } catch (std::out_of_range& e) {
27957       {
27958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27959       };
27960     } catch (std::exception& e) {
27961       {
27962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27963       };
27964     } catch (Dali::DaliException e) {
27965       {
27966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27967       };
27968     } catch (...) {
27969       {
27970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27971       };
27972     }
27973   }
27974
27975   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27976   return jresult;
27977 }
27978
27979
27980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27981   int jresult ;
27982   int result;
27983
27984   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27985   jresult = (int)result;
27986   return jresult;
27987 }
27988
27989
27990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27991   int jresult ;
27992   int result;
27993
27994   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27995   jresult = (int)result;
27996   return jresult;
27997 }
27998
27999
28000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28001   int jresult ;
28002   int result;
28003
28004   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28005   jresult = (int)result;
28006   return jresult;
28007 }
28008
28009
28010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28011   int jresult ;
28012   int result;
28013
28014   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28015   jresult = (int)result;
28016   return jresult;
28017 }
28018
28019
28020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28021   void * jresult ;
28022   Dali::RenderTask::Property *result = 0 ;
28023
28024   {
28025     try {
28026       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28027     } catch (std::out_of_range& e) {
28028       {
28029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28030       };
28031     } catch (std::exception& e) {
28032       {
28033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28034       };
28035     } catch (Dali::DaliException e) {
28036       {
28037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28038       };
28039     } catch (...) {
28040       {
28041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28042       };
28043     }
28044   }
28045
28046   jresult = (void *)result;
28047   return jresult;
28048 }
28049
28050
28051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28052   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28053
28054   arg1 = (Dali::RenderTask::Property *)jarg1;
28055   {
28056     try {
28057       delete arg1;
28058     } catch (std::out_of_range& e) {
28059       {
28060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28061       };
28062     } catch (std::exception& e) {
28063       {
28064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28065       };
28066     } catch (Dali::DaliException e) {
28067       {
28068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28069       };
28070     } catch (...) {
28071       {
28072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28073       };
28074     }
28075   }
28076
28077 }
28078
28079
28080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28081   void * jresult ;
28082   bool (*result)(Dali::Vector2 &) = 0 ;
28083
28084   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28085   jresult = (void *)result;
28086   return jresult;
28087 }
28088
28089
28090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28091   void * jresult ;
28092   bool (*result)(Dali::Vector2 &) = 0 ;
28093
28094   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28095   jresult = (void *)result;
28096   return jresult;
28097 }
28098
28099
28100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28101   unsigned int jresult ;
28102   bool result;
28103
28104   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28105   jresult = result;
28106   return jresult;
28107 }
28108
28109
28110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28111   unsigned int jresult ;
28112   bool result;
28113
28114   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28115   jresult = result;
28116   return jresult;
28117 }
28118
28119
28120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28121   void * jresult ;
28122   Dali::Vector4 *result = 0 ;
28123
28124   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28125   jresult = (void *)result;
28126   return jresult;
28127 }
28128
28129
28130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28131   unsigned int jresult ;
28132   bool result;
28133
28134   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28135   jresult = result;
28136   return jresult;
28137 }
28138
28139
28140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28141   unsigned int jresult ;
28142   bool result;
28143
28144   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28145   jresult = result;
28146   return jresult;
28147 }
28148
28149
28150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28151   unsigned int jresult ;
28152   unsigned int result;
28153
28154   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28155   jresult = result;
28156   return jresult;
28157 }
28158
28159
28160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28161   void * jresult ;
28162   Dali::RenderTask *result = 0 ;
28163
28164   {
28165     try {
28166       result = (Dali::RenderTask *)new Dali::RenderTask();
28167     } catch (std::out_of_range& e) {
28168       {
28169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28170       };
28171     } catch (std::exception& e) {
28172       {
28173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28174       };
28175     } catch (Dali::DaliException e) {
28176       {
28177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28178       };
28179     } catch (...) {
28180       {
28181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28182       };
28183     }
28184   }
28185
28186   jresult = (void *)result;
28187   return jresult;
28188 }
28189
28190
28191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28192   void * jresult ;
28193   Dali::BaseHandle arg1 ;
28194   Dali::BaseHandle *argp1 ;
28195   Dali::RenderTask result;
28196
28197   argp1 = (Dali::BaseHandle *)jarg1;
28198   if (!argp1) {
28199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28200     return 0;
28201   }
28202   arg1 = *argp1;
28203   {
28204     try {
28205       result = Dali::RenderTask::DownCast(arg1);
28206     } catch (std::out_of_range& e) {
28207       {
28208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28209       };
28210     } catch (std::exception& e) {
28211       {
28212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28213       };
28214     } catch (Dali::DaliException e) {
28215       {
28216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28217       };
28218     } catch (...) {
28219       {
28220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28221       };
28222     }
28223   }
28224
28225   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28226   return jresult;
28227 }
28228
28229
28230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28231   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28232
28233   arg1 = (Dali::RenderTask *)jarg1;
28234   {
28235     try {
28236       delete arg1;
28237     } catch (std::out_of_range& e) {
28238       {
28239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28240       };
28241     } catch (std::exception& e) {
28242       {
28243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28244       };
28245     } catch (Dali::DaliException e) {
28246       {
28247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28248       };
28249     } catch (...) {
28250       {
28251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28252       };
28253     }
28254   }
28255
28256 }
28257
28258
28259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28260   void * jresult ;
28261   Dali::RenderTask *arg1 = 0 ;
28262   Dali::RenderTask *result = 0 ;
28263
28264   arg1 = (Dali::RenderTask *)jarg1;
28265   if (!arg1) {
28266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28267     return 0;
28268   }
28269   {
28270     try {
28271       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28272     } catch (std::out_of_range& e) {
28273       {
28274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28275       };
28276     } catch (std::exception& e) {
28277       {
28278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28279       };
28280     } catch (Dali::DaliException e) {
28281       {
28282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28283       };
28284     } catch (...) {
28285       {
28286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28287       };
28288     }
28289   }
28290
28291   jresult = (void *)result;
28292   return jresult;
28293 }
28294
28295
28296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28297   void * jresult ;
28298   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28299   Dali::RenderTask *arg2 = 0 ;
28300   Dali::RenderTask *result = 0 ;
28301
28302   arg1 = (Dali::RenderTask *)jarg1;
28303   arg2 = (Dali::RenderTask *)jarg2;
28304   if (!arg2) {
28305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28306     return 0;
28307   }
28308   {
28309     try {
28310       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28311     } catch (std::out_of_range& e) {
28312       {
28313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28314       };
28315     } catch (std::exception& e) {
28316       {
28317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28318       };
28319     } catch (Dali::DaliException e) {
28320       {
28321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28322       };
28323     } catch (...) {
28324       {
28325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28326       };
28327     }
28328   }
28329
28330   jresult = (void *)result;
28331   return jresult;
28332 }
28333
28334
28335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28336   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28337   Dali::Actor arg2 ;
28338   Dali::Actor *argp2 ;
28339
28340   arg1 = (Dali::RenderTask *)jarg1;
28341   argp2 = (Dali::Actor *)jarg2;
28342   if (!argp2) {
28343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28344     return ;
28345   }
28346   arg2 = *argp2;
28347   {
28348     try {
28349       (arg1)->SetSourceActor(arg2);
28350     } catch (std::out_of_range& e) {
28351       {
28352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28353       };
28354     } catch (std::exception& e) {
28355       {
28356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28357       };
28358     } catch (Dali::DaliException e) {
28359       {
28360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28361       };
28362     } catch (...) {
28363       {
28364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28365       };
28366     }
28367   }
28368
28369 }
28370
28371
28372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28373   void * jresult ;
28374   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28375   Dali::Actor result;
28376
28377   arg1 = (Dali::RenderTask *)jarg1;
28378   {
28379     try {
28380       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28381     } catch (std::out_of_range& e) {
28382       {
28383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28384       };
28385     } catch (std::exception& e) {
28386       {
28387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28388       };
28389     } catch (Dali::DaliException e) {
28390       {
28391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28392       };
28393     } catch (...) {
28394       {
28395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28396       };
28397     }
28398   }
28399
28400   jresult = new Dali::Actor((const Dali::Actor &)result);
28401   return jresult;
28402 }
28403
28404
28405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28406   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28407   bool arg2 ;
28408
28409   arg1 = (Dali::RenderTask *)jarg1;
28410   arg2 = jarg2 ? true : false;
28411   {
28412     try {
28413       (arg1)->SetExclusive(arg2);
28414     } catch (std::out_of_range& e) {
28415       {
28416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28417       };
28418     } catch (std::exception& e) {
28419       {
28420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28421       };
28422     } catch (Dali::DaliException e) {
28423       {
28424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28425       };
28426     } catch (...) {
28427       {
28428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28429       };
28430     }
28431   }
28432
28433 }
28434
28435
28436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28437   unsigned int jresult ;
28438   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28439   bool result;
28440
28441   arg1 = (Dali::RenderTask *)jarg1;
28442   {
28443     try {
28444       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28445     } catch (std::out_of_range& e) {
28446       {
28447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28448       };
28449     } catch (std::exception& e) {
28450       {
28451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28452       };
28453     } catch (Dali::DaliException e) {
28454       {
28455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28456       };
28457     } catch (...) {
28458       {
28459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28460       };
28461     }
28462   }
28463
28464   jresult = result;
28465   return jresult;
28466 }
28467
28468
28469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28470   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28471   bool arg2 ;
28472
28473   arg1 = (Dali::RenderTask *)jarg1;
28474   arg2 = jarg2 ? true : false;
28475   {
28476     try {
28477       (arg1)->SetInputEnabled(arg2);
28478     } catch (std::out_of_range& e) {
28479       {
28480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28481       };
28482     } catch (std::exception& e) {
28483       {
28484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28485       };
28486     } catch (Dali::DaliException e) {
28487       {
28488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28489       };
28490     } catch (...) {
28491       {
28492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28493       };
28494     }
28495   }
28496
28497 }
28498
28499
28500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28501   unsigned int jresult ;
28502   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28503   bool result;
28504
28505   arg1 = (Dali::RenderTask *)jarg1;
28506   {
28507     try {
28508       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28509     } catch (std::out_of_range& e) {
28510       {
28511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28512       };
28513     } catch (std::exception& e) {
28514       {
28515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28516       };
28517     } catch (Dali::DaliException e) {
28518       {
28519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28520       };
28521     } catch (...) {
28522       {
28523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28524       };
28525     }
28526   }
28527
28528   jresult = result;
28529   return jresult;
28530 }
28531
28532
28533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28534   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28535   Dali::CameraActor arg2 ;
28536   Dali::CameraActor *argp2 ;
28537
28538   arg1 = (Dali::RenderTask *)jarg1;
28539   argp2 = (Dali::CameraActor *)jarg2;
28540   if (!argp2) {
28541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28542     return ;
28543   }
28544   arg2 = *argp2;
28545   {
28546     try {
28547       (arg1)->SetCameraActor(arg2);
28548     } catch (std::out_of_range& e) {
28549       {
28550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28551       };
28552     } catch (std::exception& e) {
28553       {
28554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28555       };
28556     } catch (Dali::DaliException e) {
28557       {
28558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28559       };
28560     } catch (...) {
28561       {
28562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28563       };
28564     }
28565   }
28566
28567 }
28568
28569
28570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28571   void * jresult ;
28572   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28573   Dali::CameraActor result;
28574
28575   arg1 = (Dali::RenderTask *)jarg1;
28576   {
28577     try {
28578       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28579     } catch (std::out_of_range& e) {
28580       {
28581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28582       };
28583     } catch (std::exception& e) {
28584       {
28585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28586       };
28587     } catch (Dali::DaliException e) {
28588       {
28589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28590       };
28591     } catch (...) {
28592       {
28593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28594       };
28595     }
28596   }
28597
28598   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28599   return jresult;
28600 }
28601
28602
28603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28604   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28605   Dali::FrameBufferImage arg2 ;
28606   Dali::FrameBufferImage *argp2 ;
28607
28608   arg1 = (Dali::RenderTask *)jarg1;
28609   argp2 = (Dali::FrameBufferImage *)jarg2;
28610   if (!argp2) {
28611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28612     return ;
28613   }
28614   arg2 = *argp2;
28615   {
28616     try {
28617       (arg1)->SetTargetFrameBuffer(arg2);
28618     } catch (std::out_of_range& e) {
28619       {
28620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28621       };
28622     } catch (std::exception& e) {
28623       {
28624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28625       };
28626     } catch (Dali::DaliException e) {
28627       {
28628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28629       };
28630     } catch (...) {
28631       {
28632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28633       };
28634     }
28635   }
28636
28637 }
28638
28639
28640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28641   void * jresult ;
28642   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28643   Dali::FrameBufferImage result;
28644
28645   arg1 = (Dali::RenderTask *)jarg1;
28646   {
28647     try {
28648       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28649     } catch (std::out_of_range& e) {
28650       {
28651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28652       };
28653     } catch (std::exception& e) {
28654       {
28655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28656       };
28657     } catch (Dali::DaliException e) {
28658       {
28659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28660       };
28661     } catch (...) {
28662       {
28663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28664       };
28665     }
28666   }
28667
28668   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28669   return jresult;
28670 }
28671
28672
28673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28674   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28675   Dali::FrameBuffer arg2 ;
28676   Dali::FrameBuffer *argp2 ;
28677
28678   arg1 = (Dali::RenderTask *)jarg1;
28679   argp2 = (Dali::FrameBuffer *)jarg2;
28680   if (!argp2) {
28681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28682     return ;
28683   }
28684   arg2 = *argp2;
28685   {
28686     try {
28687       (arg1)->SetFrameBuffer(arg2);
28688     } catch (std::out_of_range& e) {
28689       {
28690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28691       };
28692     } catch (std::exception& e) {
28693       {
28694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28695       };
28696     } catch (Dali::DaliException e) {
28697       {
28698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28699       };
28700     } catch (...) {
28701       {
28702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28703       };
28704     }
28705   }
28706
28707 }
28708
28709
28710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28711   void * jresult ;
28712   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28713   Dali::FrameBuffer result;
28714
28715   arg1 = (Dali::RenderTask *)jarg1;
28716   {
28717     try {
28718       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28719     } catch (std::out_of_range& e) {
28720       {
28721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28722       };
28723     } catch (std::exception& e) {
28724       {
28725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28726       };
28727     } catch (Dali::DaliException e) {
28728       {
28729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28730       };
28731     } catch (...) {
28732       {
28733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28734       };
28735     }
28736   }
28737
28738   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28739   return jresult;
28740 }
28741
28742
28743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28744   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28745   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28746
28747   arg1 = (Dali::RenderTask *)jarg1;
28748   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28749   {
28750     try {
28751       (arg1)->SetScreenToFrameBufferFunction(arg2);
28752     } catch (std::out_of_range& e) {
28753       {
28754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28755       };
28756     } catch (std::exception& e) {
28757       {
28758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28759       };
28760     } catch (Dali::DaliException e) {
28761       {
28762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28763       };
28764     } catch (...) {
28765       {
28766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28767       };
28768     }
28769   }
28770
28771 }
28772
28773
28774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28775   void * jresult ;
28776   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28777   Dali::RenderTask::ScreenToFrameBufferFunction result;
28778
28779   arg1 = (Dali::RenderTask *)jarg1;
28780   {
28781     try {
28782       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28783     } catch (std::out_of_range& e) {
28784       {
28785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28786       };
28787     } catch (std::exception& e) {
28788       {
28789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28790       };
28791     } catch (Dali::DaliException e) {
28792       {
28793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28794       };
28795     } catch (...) {
28796       {
28797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28798       };
28799     }
28800   }
28801
28802   jresult = (void *)result;
28803   return jresult;
28804 }
28805
28806
28807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28808   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28809   Dali::Actor arg2 ;
28810   Dali::Actor *argp2 ;
28811
28812   arg1 = (Dali::RenderTask *)jarg1;
28813   argp2 = (Dali::Actor *)jarg2;
28814   if (!argp2) {
28815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28816     return ;
28817   }
28818   arg2 = *argp2;
28819   {
28820     try {
28821       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28822     } catch (std::out_of_range& e) {
28823       {
28824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28825       };
28826     } catch (std::exception& e) {
28827       {
28828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28829       };
28830     } catch (Dali::DaliException e) {
28831       {
28832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28833       };
28834     } catch (...) {
28835       {
28836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28837       };
28838     }
28839   }
28840
28841 }
28842
28843
28844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28845   void * jresult ;
28846   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28847   Dali::Actor result;
28848
28849   arg1 = (Dali::RenderTask *)jarg1;
28850   {
28851     try {
28852       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28853     } catch (std::out_of_range& e) {
28854       {
28855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28856       };
28857     } catch (std::exception& e) {
28858       {
28859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28860       };
28861     } catch (Dali::DaliException e) {
28862       {
28863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28864       };
28865     } catch (...) {
28866       {
28867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28868       };
28869     }
28870   }
28871
28872   jresult = new Dali::Actor((const Dali::Actor &)result);
28873   return jresult;
28874 }
28875
28876
28877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28878   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28879   Dali::Vector2 arg2 ;
28880   Dali::Vector2 *argp2 ;
28881
28882   arg1 = (Dali::RenderTask *)jarg1;
28883   argp2 = (Dali::Vector2 *)jarg2;
28884   if (!argp2) {
28885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28886     return ;
28887   }
28888   arg2 = *argp2;
28889   {
28890     try {
28891       (arg1)->SetViewportPosition(arg2);
28892     } catch (std::out_of_range& e) {
28893       {
28894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28895       };
28896     } catch (std::exception& e) {
28897       {
28898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28899       };
28900     } catch (Dali::DaliException e) {
28901       {
28902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28903       };
28904     } catch (...) {
28905       {
28906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28907       };
28908     }
28909   }
28910
28911 }
28912
28913
28914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28915   void * jresult ;
28916   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28917   Dali::Vector2 result;
28918
28919   arg1 = (Dali::RenderTask *)jarg1;
28920   {
28921     try {
28922       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28923     } catch (std::out_of_range& e) {
28924       {
28925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28926       };
28927     } catch (std::exception& e) {
28928       {
28929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28930       };
28931     } catch (Dali::DaliException e) {
28932       {
28933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28934       };
28935     } catch (...) {
28936       {
28937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28938       };
28939     }
28940   }
28941
28942   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28943   return jresult;
28944 }
28945
28946
28947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28948   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28949   Dali::Vector2 arg2 ;
28950   Dali::Vector2 *argp2 ;
28951
28952   arg1 = (Dali::RenderTask *)jarg1;
28953   argp2 = (Dali::Vector2 *)jarg2;
28954   if (!argp2) {
28955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28956     return ;
28957   }
28958   arg2 = *argp2;
28959   {
28960     try {
28961       (arg1)->SetViewportSize(arg2);
28962     } catch (std::out_of_range& e) {
28963       {
28964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28965       };
28966     } catch (std::exception& e) {
28967       {
28968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28969       };
28970     } catch (Dali::DaliException e) {
28971       {
28972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28973       };
28974     } catch (...) {
28975       {
28976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28977       };
28978     }
28979   }
28980
28981 }
28982
28983
28984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28985   void * jresult ;
28986   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28987   Dali::Vector2 result;
28988
28989   arg1 = (Dali::RenderTask *)jarg1;
28990   {
28991     try {
28992       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28993     } catch (std::out_of_range& e) {
28994       {
28995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28996       };
28997     } catch (std::exception& e) {
28998       {
28999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29000       };
29001     } catch (Dali::DaliException e) {
29002       {
29003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29004       };
29005     } catch (...) {
29006       {
29007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29008       };
29009     }
29010   }
29011
29012   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29013   return jresult;
29014 }
29015
29016
29017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29018   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29019   Dali::Viewport arg2 ;
29020   Dali::Viewport *argp2 ;
29021
29022   arg1 = (Dali::RenderTask *)jarg1;
29023   argp2 = (Dali::Viewport *)jarg2;
29024   if (!argp2) {
29025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29026     return ;
29027   }
29028   arg2 = *argp2;
29029   {
29030     try {
29031       (arg1)->SetViewport(arg2);
29032     } catch (std::out_of_range& e) {
29033       {
29034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29035       };
29036     } catch (std::exception& e) {
29037       {
29038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29039       };
29040     } catch (Dali::DaliException e) {
29041       {
29042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29043       };
29044     } catch (...) {
29045       {
29046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29047       };
29048     }
29049   }
29050
29051 }
29052
29053
29054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29055   void * jresult ;
29056   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29057   Dali::Viewport result;
29058
29059   arg1 = (Dali::RenderTask *)jarg1;
29060   {
29061     try {
29062       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29063     } catch (std::out_of_range& e) {
29064       {
29065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29066       };
29067     } catch (std::exception& e) {
29068       {
29069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29070       };
29071     } catch (Dali::DaliException e) {
29072       {
29073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29074       };
29075     } catch (...) {
29076       {
29077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29078       };
29079     }
29080   }
29081
29082   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29083   return jresult;
29084 }
29085
29086
29087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29088   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29089   Dali::Vector4 *arg2 = 0 ;
29090
29091   arg1 = (Dali::RenderTask *)jarg1;
29092   arg2 = (Dali::Vector4 *)jarg2;
29093   if (!arg2) {
29094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29095     return ;
29096   }
29097   {
29098     try {
29099       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29100     } catch (std::out_of_range& e) {
29101       {
29102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29103       };
29104     } catch (std::exception& e) {
29105       {
29106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29107       };
29108     } catch (Dali::DaliException e) {
29109       {
29110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29111       };
29112     } catch (...) {
29113       {
29114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29115       };
29116     }
29117   }
29118
29119 }
29120
29121
29122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29123   void * jresult ;
29124   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29125   Dali::Vector4 result;
29126
29127   arg1 = (Dali::RenderTask *)jarg1;
29128   {
29129     try {
29130       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29131     } catch (std::out_of_range& e) {
29132       {
29133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29134       };
29135     } catch (std::exception& e) {
29136       {
29137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29138       };
29139     } catch (Dali::DaliException e) {
29140       {
29141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29142       };
29143     } catch (...) {
29144       {
29145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29146       };
29147     }
29148   }
29149
29150   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29151   return jresult;
29152 }
29153
29154
29155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29156   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29157   bool arg2 ;
29158
29159   arg1 = (Dali::RenderTask *)jarg1;
29160   arg2 = jarg2 ? true : false;
29161   {
29162     try {
29163       (arg1)->SetClearEnabled(arg2);
29164     } catch (std::out_of_range& e) {
29165       {
29166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29167       };
29168     } catch (std::exception& e) {
29169       {
29170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29171       };
29172     } catch (Dali::DaliException e) {
29173       {
29174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29175       };
29176     } catch (...) {
29177       {
29178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29179       };
29180     }
29181   }
29182
29183 }
29184
29185
29186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29187   unsigned int jresult ;
29188   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29189   bool result;
29190
29191   arg1 = (Dali::RenderTask *)jarg1;
29192   {
29193     try {
29194       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29195     } catch (std::out_of_range& e) {
29196       {
29197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29198       };
29199     } catch (std::exception& e) {
29200       {
29201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29202       };
29203     } catch (Dali::DaliException e) {
29204       {
29205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29206       };
29207     } catch (...) {
29208       {
29209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29210       };
29211     }
29212   }
29213
29214   jresult = result;
29215   return jresult;
29216 }
29217
29218
29219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29220   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29221   bool arg2 ;
29222
29223   arg1 = (Dali::RenderTask *)jarg1;
29224   arg2 = jarg2 ? true : false;
29225   {
29226     try {
29227       (arg1)->SetCullMode(arg2);
29228     } catch (std::out_of_range& e) {
29229       {
29230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29231       };
29232     } catch (std::exception& e) {
29233       {
29234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29235       };
29236     } catch (Dali::DaliException e) {
29237       {
29238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29239       };
29240     } catch (...) {
29241       {
29242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29243       };
29244     }
29245   }
29246
29247 }
29248
29249
29250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29251   unsigned int jresult ;
29252   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29253   bool result;
29254
29255   arg1 = (Dali::RenderTask *)jarg1;
29256   {
29257     try {
29258       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29259     } catch (std::out_of_range& e) {
29260       {
29261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29262       };
29263     } catch (std::exception& e) {
29264       {
29265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29266       };
29267     } catch (Dali::DaliException e) {
29268       {
29269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29270       };
29271     } catch (...) {
29272       {
29273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29274       };
29275     }
29276   }
29277
29278   jresult = result;
29279   return jresult;
29280 }
29281
29282
29283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29284   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29285   unsigned int arg2 ;
29286
29287   arg1 = (Dali::RenderTask *)jarg1;
29288   arg2 = (unsigned int)jarg2;
29289   {
29290     try {
29291       (arg1)->SetRefreshRate(arg2);
29292     } catch (std::out_of_range& e) {
29293       {
29294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29295       };
29296     } catch (std::exception& e) {
29297       {
29298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29299       };
29300     } catch (Dali::DaliException e) {
29301       {
29302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29303       };
29304     } catch (...) {
29305       {
29306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29307       };
29308     }
29309   }
29310
29311 }
29312
29313
29314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29315   unsigned int jresult ;
29316   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29317   unsigned int result;
29318
29319   arg1 = (Dali::RenderTask *)jarg1;
29320   {
29321     try {
29322       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29323     } catch (std::out_of_range& e) {
29324       {
29325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29326       };
29327     } catch (std::exception& e) {
29328       {
29329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29330       };
29331     } catch (Dali::DaliException e) {
29332       {
29333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29334       };
29335     } catch (...) {
29336       {
29337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29338       };
29339     }
29340   }
29341
29342   jresult = result;
29343   return jresult;
29344 }
29345
29346
29347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29348   unsigned int jresult ;
29349   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29350   Dali::Vector3 *arg2 = 0 ;
29351   float *arg3 = 0 ;
29352   float *arg4 = 0 ;
29353   bool result;
29354
29355   arg1 = (Dali::RenderTask *)jarg1;
29356   arg2 = (Dali::Vector3 *)jarg2;
29357   if (!arg2) {
29358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29359     return 0;
29360   }
29361   arg3 = (float *)jarg3;
29362   arg4 = (float *)jarg4;
29363   {
29364     try {
29365       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29366     } catch (std::out_of_range& e) {
29367       {
29368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29369       };
29370     } catch (std::exception& e) {
29371       {
29372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29373       };
29374     } catch (Dali::DaliException e) {
29375       {
29376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29377       };
29378     } catch (...) {
29379       {
29380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29381       };
29382     }
29383   }
29384
29385   jresult = result;
29386   return jresult;
29387 }
29388
29389
29390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29391   unsigned int jresult ;
29392   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29393   Dali::Actor arg2 ;
29394   float arg3 ;
29395   float arg4 ;
29396   float *arg5 = 0 ;
29397   float *arg6 = 0 ;
29398   Dali::Actor *argp2 ;
29399   bool result;
29400
29401   arg1 = (Dali::RenderTask *)jarg1;
29402   argp2 = (Dali::Actor *)jarg2;
29403   if (!argp2) {
29404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29405     return 0;
29406   }
29407   arg2 = *argp2;
29408   arg3 = (float)jarg3;
29409   arg4 = (float)jarg4;
29410   arg5 = (float *)jarg5;
29411   arg6 = (float *)jarg6;
29412   {
29413     try {
29414       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29415     } catch (std::out_of_range& e) {
29416       {
29417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29418       };
29419     } catch (std::exception& e) {
29420       {
29421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29422       };
29423     } catch (Dali::DaliException e) {
29424       {
29425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29426       };
29427     } catch (...) {
29428       {
29429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29430       };
29431     }
29432   }
29433
29434   jresult = result;
29435   return jresult;
29436 }
29437
29438
29439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29440   void * jresult ;
29441   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29442   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29443
29444   arg1 = (Dali::RenderTask *)jarg1;
29445   {
29446     try {
29447       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29448     } catch (std::out_of_range& e) {
29449       {
29450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29451       };
29452     } catch (std::exception& e) {
29453       {
29454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29455       };
29456     } catch (Dali::DaliException e) {
29457       {
29458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29459       };
29460     } catch (...) {
29461       {
29462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29463       };
29464     }
29465   }
29466
29467   jresult = (void *)result;
29468   return jresult;
29469 }
29470
29471
29472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29473   void * jresult ;
29474   int arg1 ;
29475   Dali::TouchPoint::State arg2 ;
29476   float arg3 ;
29477   float arg4 ;
29478   Dali::TouchPoint *result = 0 ;
29479
29480   arg1 = (int)jarg1;
29481   arg2 = (Dali::TouchPoint::State)jarg2;
29482   arg3 = (float)jarg3;
29483   arg4 = (float)jarg4;
29484   {
29485     try {
29486       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29487     } catch (std::out_of_range& e) {
29488       {
29489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29490       };
29491     } catch (std::exception& e) {
29492       {
29493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29494       };
29495     } catch (Dali::DaliException e) {
29496       {
29497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29498       };
29499     } catch (...) {
29500       {
29501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29502       };
29503     }
29504   }
29505
29506   jresult = (void *)result;
29507   return jresult;
29508 }
29509
29510
29511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29512   void * jresult ;
29513   int arg1 ;
29514   Dali::TouchPoint::State arg2 ;
29515   float arg3 ;
29516   float arg4 ;
29517   float arg5 ;
29518   float arg6 ;
29519   Dali::TouchPoint *result = 0 ;
29520
29521   arg1 = (int)jarg1;
29522   arg2 = (Dali::TouchPoint::State)jarg2;
29523   arg3 = (float)jarg3;
29524   arg4 = (float)jarg4;
29525   arg5 = (float)jarg5;
29526   arg6 = (float)jarg6;
29527   {
29528     try {
29529       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29530     } catch (std::out_of_range& e) {
29531       {
29532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29533       };
29534     } catch (std::exception& e) {
29535       {
29536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29537       };
29538     } catch (Dali::DaliException e) {
29539       {
29540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29541       };
29542     } catch (...) {
29543       {
29544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29545       };
29546     }
29547   }
29548
29549   jresult = (void *)result;
29550   return jresult;
29551 }
29552
29553
29554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29555   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29556
29557   arg1 = (Dali::TouchPoint *)jarg1;
29558   {
29559     try {
29560       delete arg1;
29561     } catch (std::out_of_range& e) {
29562       {
29563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29564       };
29565     } catch (std::exception& e) {
29566       {
29567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29568       };
29569     } catch (Dali::DaliException e) {
29570       {
29571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29572       };
29573     } catch (...) {
29574       {
29575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29576       };
29577     }
29578   }
29579
29580 }
29581
29582
29583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29584   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29585   int arg2 ;
29586
29587   arg1 = (Dali::TouchPoint *)jarg1;
29588   arg2 = (int)jarg2;
29589   if (arg1) (arg1)->deviceId = arg2;
29590 }
29591
29592
29593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29594   int jresult ;
29595   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29596   int result;
29597
29598   arg1 = (Dali::TouchPoint *)jarg1;
29599   result = (int) ((arg1)->deviceId);
29600   jresult = result;
29601   return jresult;
29602 }
29603
29604
29605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29606   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29607   Dali::TouchPoint::State arg2 ;
29608
29609   arg1 = (Dali::TouchPoint *)jarg1;
29610   arg2 = (Dali::TouchPoint::State)jarg2;
29611   if (arg1) (arg1)->state = arg2;
29612 }
29613
29614
29615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29616   int jresult ;
29617   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29618   Dali::TouchPoint::State result;
29619
29620   arg1 = (Dali::TouchPoint *)jarg1;
29621   result = (Dali::TouchPoint::State) ((arg1)->state);
29622   jresult = (int)result;
29623   return jresult;
29624 }
29625
29626
29627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29628   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29629   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29630
29631   arg1 = (Dali::TouchPoint *)jarg1;
29632   arg2 = (Dali::Actor *)jarg2;
29633   if (arg1) (arg1)->hitActor = *arg2;
29634 }
29635
29636
29637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29638   void * jresult ;
29639   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29640   Dali::Actor *result = 0 ;
29641
29642   arg1 = (Dali::TouchPoint *)jarg1;
29643   result = (Dali::Actor *)& ((arg1)->hitActor);
29644   jresult = (void *)result;
29645   return jresult;
29646 }
29647
29648
29649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29650   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29651   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29652
29653   arg1 = (Dali::TouchPoint *)jarg1;
29654   arg2 = (Dali::Vector2 *)jarg2;
29655   if (arg1) (arg1)->local = *arg2;
29656 }
29657
29658
29659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29660   void * jresult ;
29661   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29662   Dali::Vector2 *result = 0 ;
29663
29664   arg1 = (Dali::TouchPoint *)jarg1;
29665   result = (Dali::Vector2 *)& ((arg1)->local);
29666   jresult = (void *)result;
29667   return jresult;
29668 }
29669
29670
29671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29672   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29673   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29674
29675   arg1 = (Dali::TouchPoint *)jarg1;
29676   arg2 = (Dali::Vector2 *)jarg2;
29677   if (arg1) (arg1)->screen = *arg2;
29678 }
29679
29680
29681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29682   void * jresult ;
29683   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29684   Dali::Vector2 *result = 0 ;
29685
29686   arg1 = (Dali::TouchPoint *)jarg1;
29687   result = (Dali::Vector2 *)& ((arg1)->screen);
29688   jresult = (void *)result;
29689   return jresult;
29690 }
29691
29692
29693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29694   void * jresult ;
29695   Dali::TouchData *result = 0 ;
29696
29697   {
29698     try {
29699       result = (Dali::TouchData *)new Dali::TouchData();
29700     } catch (std::out_of_range& e) {
29701       {
29702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29703       };
29704     } catch (std::exception& e) {
29705       {
29706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29707       };
29708     } catch (Dali::DaliException e) {
29709       {
29710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29711       };
29712     } catch (...) {
29713       {
29714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29715       };
29716     }
29717   }
29718
29719   jresult = (void *)result;
29720   return jresult;
29721 }
29722
29723
29724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29725   void * jresult ;
29726   Dali::TouchData *arg1 = 0 ;
29727   Dali::TouchData *result = 0 ;
29728
29729   arg1 = (Dali::TouchData *)jarg1;
29730   if (!arg1) {
29731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29732     return 0;
29733   }
29734   {
29735     try {
29736       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29737     } catch (std::out_of_range& e) {
29738       {
29739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29740       };
29741     } catch (std::exception& e) {
29742       {
29743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29744       };
29745     } catch (Dali::DaliException e) {
29746       {
29747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29748       };
29749     } catch (...) {
29750       {
29751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29752       };
29753     }
29754   }
29755
29756   jresult = (void *)result;
29757   return jresult;
29758 }
29759
29760
29761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29762   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29763
29764   arg1 = (Dali::TouchData *)jarg1;
29765   {
29766     try {
29767       delete arg1;
29768     } catch (std::out_of_range& e) {
29769       {
29770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29771       };
29772     } catch (std::exception& e) {
29773       {
29774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29775       };
29776     } catch (Dali::DaliException e) {
29777       {
29778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29779       };
29780     } catch (...) {
29781       {
29782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29783       };
29784     }
29785   }
29786
29787 }
29788
29789
29790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29791   void * jresult ;
29792   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29793   Dali::TouchData *arg2 = 0 ;
29794   Dali::TouchData *result = 0 ;
29795
29796   arg1 = (Dali::TouchData *)jarg1;
29797   arg2 = (Dali::TouchData *)jarg2;
29798   if (!arg2) {
29799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29800     return 0;
29801   }
29802   {
29803     try {
29804       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29805     } catch (std::out_of_range& e) {
29806       {
29807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29808       };
29809     } catch (std::exception& e) {
29810       {
29811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29812       };
29813     } catch (Dali::DaliException e) {
29814       {
29815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29816       };
29817     } catch (...) {
29818       {
29819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29820       };
29821     }
29822   }
29823
29824   jresult = (void *)result;
29825   return jresult;
29826 }
29827
29828
29829 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29830   unsigned long jresult ;
29831   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29832   unsigned long result;
29833
29834   arg1 = (Dali::TouchData *)jarg1;
29835   {
29836     try {
29837       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29838     } catch (std::out_of_range& e) {
29839       {
29840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29841       };
29842     } catch (std::exception& e) {
29843       {
29844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29845       };
29846     } catch (Dali::DaliException e) {
29847       {
29848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29849       };
29850     } catch (...) {
29851       {
29852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29853       };
29854     }
29855   }
29856
29857   jresult = (unsigned long)result;
29858   return jresult;
29859 }
29860
29861
29862 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29863   unsigned long jresult ;
29864   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29865   std::size_t result;
29866
29867   arg1 = (Dali::TouchData *)jarg1;
29868   {
29869     try {
29870       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29871     } catch (std::out_of_range& e) {
29872       {
29873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29874       };
29875     } catch (std::exception& e) {
29876       {
29877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29878       };
29879     } catch (Dali::DaliException e) {
29880       {
29881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29882       };
29883     } catch (...) {
29884       {
29885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29886       };
29887     }
29888   }
29889
29890   jresult = (unsigned long)result;
29891   return jresult;
29892 }
29893
29894
29895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29896   int jresult ;
29897   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29898   std::size_t arg2 ;
29899   int32_t result;
29900
29901   arg1 = (Dali::TouchData *)jarg1;
29902   arg2 = (std::size_t)jarg2;
29903   {
29904     try {
29905       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29906     } catch (std::out_of_range& e) {
29907       {
29908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29909       };
29910     } catch (std::exception& e) {
29911       {
29912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29913       };
29914     } catch (Dali::DaliException e) {
29915       {
29916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29917       };
29918     } catch (...) {
29919       {
29920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29921       };
29922     }
29923   }
29924
29925   jresult = result;
29926   return jresult;
29927 }
29928
29929
29930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29931   int jresult ;
29932   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29933   std::size_t arg2 ;
29934   Dali::PointState::Type result;
29935
29936   arg1 = (Dali::TouchData *)jarg1;
29937   arg2 = (std::size_t)jarg2;
29938   {
29939     try {
29940       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29941     } catch (std::out_of_range& e) {
29942       {
29943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29944       };
29945     } catch (std::exception& e) {
29946       {
29947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29948       };
29949     } catch (Dali::DaliException e) {
29950       {
29951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29952       };
29953     } catch (...) {
29954       {
29955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29956       };
29957     }
29958   }
29959
29960   jresult = (int)result;
29961   return jresult;
29962 }
29963
29964
29965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29966   void * jresult ;
29967   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29968   std::size_t arg2 ;
29969   Dali::Actor result;
29970
29971   arg1 = (Dali::TouchData *)jarg1;
29972   arg2 = (std::size_t)jarg2;
29973   {
29974     try {
29975       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29976     } catch (std::out_of_range& e) {
29977       {
29978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29979       };
29980     } catch (std::exception& e) {
29981       {
29982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29983       };
29984     } catch (Dali::DaliException e) {
29985       {
29986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29987       };
29988     } catch (...) {
29989       {
29990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29991       };
29992     }
29993   }
29994
29995   jresult = new Dali::Actor((const Dali::Actor &)result);
29996   return jresult;
29997 }
29998
29999
30000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30001   void * jresult ;
30002   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30003   std::size_t arg2 ;
30004   Dali::Vector2 *result = 0 ;
30005
30006   arg1 = (Dali::TouchData *)jarg1;
30007   arg2 = (std::size_t)jarg2;
30008   {
30009     try {
30010       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30011     } catch (std::out_of_range& e) {
30012       {
30013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30014       };
30015     } catch (std::exception& e) {
30016       {
30017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30018       };
30019     } catch (Dali::DaliException e) {
30020       {
30021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30022       };
30023     } catch (...) {
30024       {
30025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30026       };
30027     }
30028   }
30029
30030   jresult = (void *)result;
30031   return jresult;
30032 }
30033
30034
30035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30036   void * jresult ;
30037   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30038   std::size_t arg2 ;
30039   Dali::Vector2 *result = 0 ;
30040
30041   arg1 = (Dali::TouchData *)jarg1;
30042   arg2 = (std::size_t)jarg2;
30043   {
30044     try {
30045       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30046     } catch (std::out_of_range& e) {
30047       {
30048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30049       };
30050     } catch (std::exception& e) {
30051       {
30052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30053       };
30054     } catch (Dali::DaliException e) {
30055       {
30056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30057       };
30058     } catch (...) {
30059       {
30060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30061       };
30062     }
30063   }
30064
30065   jresult = (void *)result;
30066   return jresult;
30067 }
30068
30069
30070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30071   float jresult ;
30072   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30073   std::size_t arg2 ;
30074   float result;
30075
30076   arg1 = (Dali::TouchData *)jarg1;
30077   arg2 = (std::size_t)jarg2;
30078   {
30079     try {
30080       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30081     } catch (std::out_of_range& e) {
30082       {
30083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30084       };
30085     } catch (std::exception& e) {
30086       {
30087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30088       };
30089     } catch (Dali::DaliException e) {
30090       {
30091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30092       };
30093     } catch (...) {
30094       {
30095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30096       };
30097     }
30098   }
30099
30100   jresult = result;
30101   return jresult;
30102 }
30103
30104
30105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30106   void * jresult ;
30107   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30108   std::size_t arg2 ;
30109   Dali::Vector2 *result = 0 ;
30110
30111   arg1 = (Dali::TouchData *)jarg1;
30112   arg2 = (std::size_t)jarg2;
30113   {
30114     try {
30115       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30116     } catch (std::out_of_range& e) {
30117       {
30118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30119       };
30120     } catch (std::exception& e) {
30121       {
30122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30123       };
30124     } catch (Dali::DaliException e) {
30125       {
30126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30127       };
30128     } catch (...) {
30129       {
30130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30131       };
30132     }
30133   }
30134
30135   jresult = (void *)result;
30136   return jresult;
30137 }
30138
30139
30140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30141   float jresult ;
30142   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30143   std::size_t arg2 ;
30144   float result;
30145
30146   arg1 = (Dali::TouchData *)jarg1;
30147   arg2 = (std::size_t)jarg2;
30148   {
30149     try {
30150       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30151     } catch (std::out_of_range& e) {
30152       {
30153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30154       };
30155     } catch (std::exception& e) {
30156       {
30157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30158       };
30159     } catch (Dali::DaliException e) {
30160       {
30161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30162       };
30163     } catch (...) {
30164       {
30165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30166       };
30167     }
30168   }
30169
30170   jresult = result;
30171   return jresult;
30172 }
30173
30174
30175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30176   void * jresult ;
30177   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30178   std::size_t arg2 ;
30179   Dali::Degree result;
30180
30181   arg1 = (Dali::TouchData *)jarg1;
30182   arg2 = (std::size_t)jarg2;
30183   {
30184     try {
30185       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30186     } catch (std::out_of_range& e) {
30187       {
30188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30189       };
30190     } catch (std::exception& e) {
30191       {
30192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30193       };
30194     } catch (Dali::DaliException e) {
30195       {
30196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30197       };
30198     } catch (...) {
30199       {
30200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30201       };
30202     }
30203   }
30204
30205   jresult = new Dali::Degree((const Dali::Degree &)result);
30206   return jresult;
30207 }
30208
30209
30210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30211   int jresult ;
30212   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30213   std::size_t arg2 ;
30214   Dali::MouseButton::Type result;
30215
30216   arg1 = (Dali::TouchData *)jarg1;
30217   arg2 = (std::size_t)jarg2;
30218   {
30219     try {
30220       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30221     } catch (std::out_of_range& e) {
30222       {
30223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30224       };
30225     } catch (std::exception& e) {
30226       {
30227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30228       };
30229     } catch (Dali::DaliException e) {
30230       {
30231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30232       };
30233     } catch (...) {
30234       {
30235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30236       };
30237     }
30238   }
30239
30240   jresult = static_cast< int >(result);
30241   return jresult;
30242 }
30243
30244
30245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30246   void * jresult ;
30247   Dali::GestureDetector *result = 0 ;
30248
30249   {
30250     try {
30251       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30252     } catch (std::out_of_range& e) {
30253       {
30254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30255       };
30256     } catch (std::exception& e) {
30257       {
30258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30259       };
30260     } catch (Dali::DaliException e) {
30261       {
30262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30263       };
30264     } catch (...) {
30265       {
30266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30267       };
30268     }
30269   }
30270
30271   jresult = (void *)result;
30272   return jresult;
30273 }
30274
30275
30276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30277   void * jresult ;
30278   Dali::BaseHandle arg1 ;
30279   Dali::BaseHandle *argp1 ;
30280   Dali::GestureDetector result;
30281
30282   argp1 = (Dali::BaseHandle *)jarg1;
30283   if (!argp1) {
30284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30285     return 0;
30286   }
30287   arg1 = *argp1;
30288   {
30289     try {
30290       result = Dali::GestureDetector::DownCast(arg1);
30291     } catch (std::out_of_range& e) {
30292       {
30293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30294       };
30295     } catch (std::exception& e) {
30296       {
30297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30298       };
30299     } catch (Dali::DaliException e) {
30300       {
30301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30302       };
30303     } catch (...) {
30304       {
30305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30306       };
30307     }
30308   }
30309
30310   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30311   return jresult;
30312 }
30313
30314
30315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30316   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30317
30318   arg1 = (Dali::GestureDetector *)jarg1;
30319   {
30320     try {
30321       delete arg1;
30322     } catch (std::out_of_range& e) {
30323       {
30324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30325       };
30326     } catch (std::exception& e) {
30327       {
30328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30329       };
30330     } catch (Dali::DaliException e) {
30331       {
30332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30333       };
30334     } catch (...) {
30335       {
30336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30337       };
30338     }
30339   }
30340
30341 }
30342
30343
30344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30345   void * jresult ;
30346   Dali::GestureDetector *arg1 = 0 ;
30347   Dali::GestureDetector *result = 0 ;
30348
30349   arg1 = (Dali::GestureDetector *)jarg1;
30350   if (!arg1) {
30351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30352     return 0;
30353   }
30354   {
30355     try {
30356       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30357     } catch (std::out_of_range& e) {
30358       {
30359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30360       };
30361     } catch (std::exception& e) {
30362       {
30363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30364       };
30365     } catch (Dali::DaliException e) {
30366       {
30367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30368       };
30369     } catch (...) {
30370       {
30371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30372       };
30373     }
30374   }
30375
30376   jresult = (void *)result;
30377   return jresult;
30378 }
30379
30380
30381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30382   void * jresult ;
30383   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30384   Dali::GestureDetector *arg2 = 0 ;
30385   Dali::GestureDetector *result = 0 ;
30386
30387   arg1 = (Dali::GestureDetector *)jarg1;
30388   arg2 = (Dali::GestureDetector *)jarg2;
30389   if (!arg2) {
30390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30391     return 0;
30392   }
30393   {
30394     try {
30395       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30396     } catch (std::out_of_range& e) {
30397       {
30398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30399       };
30400     } catch (std::exception& e) {
30401       {
30402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30403       };
30404     } catch (Dali::DaliException e) {
30405       {
30406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30407       };
30408     } catch (...) {
30409       {
30410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30411       };
30412     }
30413   }
30414
30415   jresult = (void *)result;
30416   return jresult;
30417 }
30418
30419
30420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30421   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30422   Dali::Actor arg2 ;
30423   Dali::Actor *argp2 ;
30424
30425   arg1 = (Dali::GestureDetector *)jarg1;
30426   argp2 = (Dali::Actor *)jarg2;
30427   if (!argp2) {
30428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30429     return ;
30430   }
30431   arg2 = *argp2;
30432   {
30433     try {
30434       (arg1)->Attach(arg2);
30435     } catch (std::out_of_range& e) {
30436       {
30437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30438       };
30439     } catch (std::exception& e) {
30440       {
30441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30442       };
30443     } catch (Dali::DaliException e) {
30444       {
30445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30446       };
30447     } catch (...) {
30448       {
30449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30450       };
30451     }
30452   }
30453
30454 }
30455
30456
30457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30458   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30459   Dali::Actor arg2 ;
30460   Dali::Actor *argp2 ;
30461
30462   arg1 = (Dali::GestureDetector *)jarg1;
30463   argp2 = (Dali::Actor *)jarg2;
30464   if (!argp2) {
30465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30466     return ;
30467   }
30468   arg2 = *argp2;
30469   {
30470     try {
30471       (arg1)->Detach(arg2);
30472     } catch (std::out_of_range& e) {
30473       {
30474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30475       };
30476     } catch (std::exception& e) {
30477       {
30478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30479       };
30480     } catch (Dali::DaliException e) {
30481       {
30482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30483       };
30484     } catch (...) {
30485       {
30486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30487       };
30488     }
30489   }
30490
30491 }
30492
30493
30494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30495   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30496
30497   arg1 = (Dali::GestureDetector *)jarg1;
30498   {
30499     try {
30500       (arg1)->DetachAll();
30501     } catch (std::out_of_range& e) {
30502       {
30503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30504       };
30505     } catch (std::exception& e) {
30506       {
30507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30508       };
30509     } catch (Dali::DaliException e) {
30510       {
30511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30512       };
30513     } catch (...) {
30514       {
30515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30516       };
30517     }
30518   }
30519
30520 }
30521
30522
30523 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30524   unsigned long jresult ;
30525   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30526   size_t result;
30527
30528   arg1 = (Dali::GestureDetector *)jarg1;
30529   {
30530     try {
30531       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30532     } catch (std::out_of_range& e) {
30533       {
30534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30535       };
30536     } catch (std::exception& e) {
30537       {
30538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30539       };
30540     } catch (Dali::DaliException e) {
30541       {
30542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30543       };
30544     } catch (...) {
30545       {
30546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30547       };
30548     }
30549   }
30550
30551   jresult = (unsigned long)result;
30552   return jresult;
30553 }
30554
30555
30556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30557   void * jresult ;
30558   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30559   size_t arg2 ;
30560   Dali::Actor result;
30561
30562   arg1 = (Dali::GestureDetector *)jarg1;
30563   arg2 = (size_t)jarg2;
30564   {
30565     try {
30566       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30567     } catch (std::out_of_range& e) {
30568       {
30569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30570       };
30571     } catch (std::exception& e) {
30572       {
30573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30574       };
30575     } catch (Dali::DaliException e) {
30576       {
30577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30578       };
30579     } catch (...) {
30580       {
30581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30582       };
30583     }
30584   }
30585
30586   jresult = new Dali::Actor((const Dali::Actor &)result);
30587   return jresult;
30588 }
30589
30590
30591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30592   void * jresult ;
30593   Dali::Gesture *arg1 = 0 ;
30594   Dali::Gesture *result = 0 ;
30595
30596   arg1 = (Dali::Gesture *)jarg1;
30597   if (!arg1) {
30598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30599     return 0;
30600   }
30601   {
30602     try {
30603       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30604     } catch (std::out_of_range& e) {
30605       {
30606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30607       };
30608     } catch (std::exception& e) {
30609       {
30610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30611       };
30612     } catch (Dali::DaliException e) {
30613       {
30614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30615       };
30616     } catch (...) {
30617       {
30618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30619       };
30620     }
30621   }
30622
30623   jresult = (void *)result;
30624   return jresult;
30625 }
30626
30627
30628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30629   void * jresult ;
30630   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30631   Dali::Gesture *arg2 = 0 ;
30632   Dali::Gesture *result = 0 ;
30633
30634   arg1 = (Dali::Gesture *)jarg1;
30635   arg2 = (Dali::Gesture *)jarg2;
30636   if (!arg2) {
30637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30638     return 0;
30639   }
30640   {
30641     try {
30642       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30643     } catch (std::out_of_range& e) {
30644       {
30645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30646       };
30647     } catch (std::exception& e) {
30648       {
30649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30650       };
30651     } catch (Dali::DaliException e) {
30652       {
30653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30654       };
30655     } catch (...) {
30656       {
30657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30658       };
30659     }
30660   }
30661
30662   jresult = (void *)result;
30663   return jresult;
30664 }
30665
30666
30667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30668   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30669
30670   arg1 = (Dali::Gesture *)jarg1;
30671   {
30672     try {
30673       delete arg1;
30674     } catch (std::out_of_range& e) {
30675       {
30676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30677       };
30678     } catch (std::exception& e) {
30679       {
30680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30681       };
30682     } catch (Dali::DaliException e) {
30683       {
30684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30685       };
30686     } catch (...) {
30687       {
30688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30689       };
30690     }
30691   }
30692
30693 }
30694
30695
30696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30697   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30698   Dali::Gesture::Type arg2 ;
30699
30700   arg1 = (Dali::Gesture *)jarg1;
30701   arg2 = (Dali::Gesture::Type)jarg2;
30702   if (arg1) (arg1)->type = arg2;
30703 }
30704
30705
30706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30707   int jresult ;
30708   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30709   Dali::Gesture::Type result;
30710
30711   arg1 = (Dali::Gesture *)jarg1;
30712   result = (Dali::Gesture::Type) ((arg1)->type);
30713   jresult = (int)result;
30714   return jresult;
30715 }
30716
30717
30718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30719   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30720   Dali::Gesture::State arg2 ;
30721
30722   arg1 = (Dali::Gesture *)jarg1;
30723   arg2 = (Dali::Gesture::State)jarg2;
30724   if (arg1) (arg1)->state = arg2;
30725 }
30726
30727
30728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30729   int jresult ;
30730   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30731   Dali::Gesture::State result;
30732
30733   arg1 = (Dali::Gesture *)jarg1;
30734   result = (Dali::Gesture::State) ((arg1)->state);
30735   jresult = (int)result;
30736   return jresult;
30737 }
30738
30739
30740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30741   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30742   unsigned int arg2 ;
30743
30744   arg1 = (Dali::Gesture *)jarg1;
30745   arg2 = (unsigned int)jarg2;
30746   if (arg1) (arg1)->time = arg2;
30747 }
30748
30749
30750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30751   unsigned int jresult ;
30752   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30753   unsigned int result;
30754
30755   arg1 = (Dali::Gesture *)jarg1;
30756   result = (unsigned int) ((arg1)->time);
30757   jresult = result;
30758   return jresult;
30759 }
30760
30761
30762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30763   void * jresult ;
30764   Dali::HoverEvent *result = 0 ;
30765
30766   {
30767     try {
30768       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30769     } catch (std::out_of_range& e) {
30770       {
30771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30772       };
30773     } catch (std::exception& e) {
30774       {
30775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30776       };
30777     } catch (Dali::DaliException e) {
30778       {
30779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30780       };
30781     } catch (...) {
30782       {
30783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30784       };
30785     }
30786   }
30787
30788   jresult = (void *)result;
30789   return jresult;
30790 }
30791
30792
30793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30794   void * jresult ;
30795   unsigned long arg1 ;
30796   Dali::HoverEvent *result = 0 ;
30797
30798   arg1 = (unsigned long)jarg1;
30799   {
30800     try {
30801       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30802     } catch (std::out_of_range& e) {
30803       {
30804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30805       };
30806     } catch (std::exception& e) {
30807       {
30808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30809       };
30810     } catch (Dali::DaliException e) {
30811       {
30812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30813       };
30814     } catch (...) {
30815       {
30816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30817       };
30818     }
30819   }
30820
30821   jresult = (void *)result;
30822   return jresult;
30823 }
30824
30825
30826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30827   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30828
30829   arg1 = (Dali::HoverEvent *)jarg1;
30830   {
30831     try {
30832       delete arg1;
30833     } catch (std::out_of_range& e) {
30834       {
30835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30836       };
30837     } catch (std::exception& e) {
30838       {
30839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30840       };
30841     } catch (Dali::DaliException e) {
30842       {
30843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30844       };
30845     } catch (...) {
30846       {
30847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30848       };
30849     }
30850   }
30851
30852 }
30853
30854
30855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30856   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30857   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30858
30859   arg1 = (Dali::HoverEvent *)jarg1;
30860   arg2 = (Dali::TouchPointContainer *)jarg2;
30861   if (arg1) (arg1)->points = *arg2;
30862 }
30863
30864
30865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30866   void * jresult ;
30867   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30868   Dali::TouchPointContainer *result = 0 ;
30869
30870   arg1 = (Dali::HoverEvent *)jarg1;
30871   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30872   jresult = (void *)result;
30873   return jresult;
30874 }
30875
30876
30877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30878   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30879   unsigned long arg2 ;
30880
30881   arg1 = (Dali::HoverEvent *)jarg1;
30882   arg2 = (unsigned long)jarg2;
30883   if (arg1) (arg1)->time = arg2;
30884 }
30885
30886
30887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30888   unsigned long jresult ;
30889   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30890   unsigned long result;
30891
30892   arg1 = (Dali::HoverEvent *)jarg1;
30893   result = (unsigned long) ((arg1)->time);
30894   jresult = (unsigned long)result;
30895   return jresult;
30896 }
30897
30898
30899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30900   unsigned int jresult ;
30901   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30902   unsigned int result;
30903
30904   arg1 = (Dali::HoverEvent *)jarg1;
30905   {
30906     try {
30907       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30908     } catch (std::out_of_range& e) {
30909       {
30910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30911       };
30912     } catch (std::exception& e) {
30913       {
30914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30915       };
30916     } catch (Dali::DaliException e) {
30917       {
30918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30919       };
30920     } catch (...) {
30921       {
30922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30923       };
30924     }
30925   }
30926
30927   jresult = result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30933   void * jresult ;
30934   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30935   unsigned int arg2 ;
30936   Dali::TouchPoint *result = 0 ;
30937
30938   arg1 = (Dali::HoverEvent *)jarg1;
30939   arg2 = (unsigned int)jarg2;
30940   {
30941     try {
30942       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30943     } catch (std::out_of_range& e) {
30944       {
30945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30946       };
30947     } catch (std::exception& e) {
30948       {
30949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30950       };
30951     } catch (Dali::DaliException e) {
30952       {
30953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30954       };
30955     } catch (...) {
30956       {
30957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30958       };
30959     }
30960   }
30961
30962   jresult = (void *)result;
30963   return jresult;
30964 }
30965
30966
30967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30968   void * jresult ;
30969   Dali::KeyEvent *result = 0 ;
30970
30971   {
30972     try {
30973       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30974     } catch (std::out_of_range& e) {
30975       {
30976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30977       };
30978     } catch (std::exception& e) {
30979       {
30980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30981       };
30982     } catch (Dali::DaliException e) {
30983       {
30984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30985       };
30986     } catch (...) {
30987       {
30988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30989       };
30990     }
30991   }
30992
30993   jresult = (void *)result;
30994   return jresult;
30995 }
30996
30997
30998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30999   void * jresult ;
31000   std::string *arg1 = 0 ;
31001   std::string *arg2 = 0 ;
31002   int arg3 ;
31003   int arg4 ;
31004   unsigned long arg5 ;
31005   Dali::KeyEvent::State *arg6 = 0 ;
31006   Dali::KeyEvent::State temp6 ;
31007   Dali::KeyEvent *result = 0 ;
31008
31009   if (!jarg1) {
31010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31011     return 0;
31012   }
31013   std::string arg1_str(jarg1);
31014   arg1 = &arg1_str;
31015   if (!jarg2) {
31016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31017     return 0;
31018   }
31019   std::string arg2_str(jarg2);
31020   arg2 = &arg2_str;
31021   arg3 = (int)jarg3;
31022   arg4 = (int)jarg4;
31023   arg5 = (unsigned long)jarg5;
31024   temp6 = (Dali::KeyEvent::State)jarg6;
31025   arg6 = &temp6;
31026   {
31027     try {
31028       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31029     } catch (std::out_of_range& e) {
31030       {
31031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31032       };
31033     } catch (std::exception& e) {
31034       {
31035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31036       };
31037     } catch (Dali::DaliException e) {
31038       {
31039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31040       };
31041     } catch (...) {
31042       {
31043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31044       };
31045     }
31046   }
31047
31048   jresult = (void *)result;
31049
31050   //argout typemap for const std::string&
31051
31052
31053   //argout typemap for const std::string&
31054
31055   return jresult;
31056 }
31057
31058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31059   void * jresult ;
31060   Dali::KeyEvent *arg1 = 0 ;
31061   Dali::KeyEvent *result = 0 ;
31062
31063   arg1 = (Dali::KeyEvent *)jarg1;
31064   if (!arg1) {
31065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31066     return 0;
31067   }
31068   {
31069     try {
31070       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31071     } catch (std::out_of_range& e) {
31072       {
31073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31074       };
31075     } catch (std::exception& e) {
31076       {
31077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31078       };
31079     } catch (Dali::DaliException e) {
31080       {
31081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31082       };
31083     } catch (...) {
31084       {
31085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31086       };
31087     }
31088   }
31089
31090   jresult = (void *)result;
31091   return jresult;
31092 }
31093
31094
31095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31096   void * jresult ;
31097   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31098   Dali::KeyEvent *arg2 = 0 ;
31099   Dali::KeyEvent *result = 0 ;
31100
31101   arg1 = (Dali::KeyEvent *)jarg1;
31102   arg2 = (Dali::KeyEvent *)jarg2;
31103   if (!arg2) {
31104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31105     return 0;
31106   }
31107   {
31108     try {
31109       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31110     } catch (std::out_of_range& e) {
31111       {
31112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31113       };
31114     } catch (std::exception& e) {
31115       {
31116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31117       };
31118     } catch (Dali::DaliException e) {
31119       {
31120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31121       };
31122     } catch (...) {
31123       {
31124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31125       };
31126     }
31127   }
31128
31129   jresult = (void *)result;
31130   return jresult;
31131 }
31132
31133
31134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31135   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31136
31137   arg1 = (Dali::KeyEvent *)jarg1;
31138   {
31139     try {
31140       delete arg1;
31141     } catch (std::out_of_range& e) {
31142       {
31143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31144       };
31145     } catch (std::exception& e) {
31146       {
31147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31148       };
31149     } catch (Dali::DaliException e) {
31150       {
31151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31152       };
31153     } catch (...) {
31154       {
31155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31156       };
31157     }
31158   }
31159
31160 }
31161
31162
31163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31164   unsigned int jresult ;
31165   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31166   bool result;
31167
31168   arg1 = (Dali::KeyEvent *)jarg1;
31169   {
31170     try {
31171       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31172     } catch (std::out_of_range& e) {
31173       {
31174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31175       };
31176     } catch (std::exception& e) {
31177       {
31178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31179       };
31180     } catch (Dali::DaliException e) {
31181       {
31182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31183       };
31184     } catch (...) {
31185       {
31186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31187       };
31188     }
31189   }
31190
31191   jresult = result;
31192   return jresult;
31193 }
31194
31195
31196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31197   unsigned int jresult ;
31198   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31199   bool result;
31200
31201   arg1 = (Dali::KeyEvent *)jarg1;
31202   {
31203     try {
31204       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31205     } catch (std::out_of_range& e) {
31206       {
31207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31208       };
31209     } catch (std::exception& e) {
31210       {
31211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31212       };
31213     } catch (Dali::DaliException e) {
31214       {
31215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31216       };
31217     } catch (...) {
31218       {
31219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31220       };
31221     }
31222   }
31223
31224   jresult = result;
31225   return jresult;
31226 }
31227
31228
31229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31230   unsigned int jresult ;
31231   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31232   bool result;
31233
31234   arg1 = (Dali::KeyEvent *)jarg1;
31235   {
31236     try {
31237       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31238     } catch (std::out_of_range& e) {
31239       {
31240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31241       };
31242     } catch (std::exception& e) {
31243       {
31244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31245       };
31246     } catch (Dali::DaliException e) {
31247       {
31248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31249       };
31250     } catch (...) {
31251       {
31252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31253       };
31254     }
31255   }
31256
31257   jresult = result;
31258   return jresult;
31259 }
31260
31261
31262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31263   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31264   std::string *arg2 = 0 ;
31265
31266   arg1 = (Dali::KeyEvent *)jarg1;
31267   if (!jarg2) {
31268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31269     return ;
31270   }
31271   std::string arg2_str(jarg2);
31272   arg2 = &arg2_str;
31273   if (arg1) (arg1)->keyPressedName = *arg2;
31274
31275   //argout typemap for const std::string&
31276
31277 }
31278
31279
31280 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31281   char * jresult ;
31282
31283   if( jarg1 == NULL )
31284   {
31285     jresult = SWIG_csharp_string_callback( "" );
31286   }
31287   else
31288   {
31289     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31290     std::string *result = 0;
31291
31292     arg1 = ( Dali::KeyEvent * )jarg1;
31293     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31294     jresult = SWIG_csharp_string_callback( result->c_str() );
31295   }
31296
31297   return jresult;
31298 }
31299
31300
31301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31302   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31303   std::string *arg2 = 0 ;
31304
31305   arg1 = (Dali::KeyEvent *)jarg1;
31306   if (!jarg2) {
31307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31308     return ;
31309   }
31310   std::string arg2_str(jarg2);
31311   arg2 = &arg2_str;
31312   if (arg1) (arg1)->keyPressed = *arg2;
31313
31314   //argout typemap for const std::string&
31315
31316 }
31317
31318
31319 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31320   char * jresult ;
31321   if( NULL == jarg1 )
31322   {
31323     jresult = SWIG_csharp_string_callback( "" );
31324   }
31325   else
31326   {
31327     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31328     std::string *result = 0;
31329
31330     arg1 = ( Dali::KeyEvent * )jarg1;
31331     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31332     jresult = SWIG_csharp_string_callback( result->c_str() );
31333   }
31334   return jresult;
31335 }
31336
31337
31338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31339   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31340   int arg2 ;
31341
31342   arg1 = (Dali::KeyEvent *)jarg1;
31343   arg2 = (int)jarg2;
31344   if (arg1) (arg1)->keyCode = arg2;
31345 }
31346
31347
31348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31349   int jresult ;
31350   if( NULL == jarg1 )
31351   {
31352     jresult = -1;
31353   }
31354   else
31355   {
31356     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31357     int result;
31358
31359     arg1 = ( Dali::KeyEvent * )jarg1;
31360     result = (int)( ( arg1 )->keyCode );
31361     jresult = result;
31362   }
31363   return jresult;
31364 }
31365
31366
31367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31368   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31369   int arg2 ;
31370
31371   arg1 = (Dali::KeyEvent *)jarg1;
31372   arg2 = (int)jarg2;
31373   if (arg1) (arg1)->keyModifier = arg2;
31374 }
31375
31376
31377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31378   int jresult ;
31379   if( jarg1 == NULL )
31380   {
31381     jresult = -1;
31382   }
31383   else
31384   {
31385     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31386     int result;
31387
31388     arg1 = ( Dali::KeyEvent * )jarg1;
31389     result = (int)( ( arg1 )->keyModifier );
31390     jresult = result;
31391   }
31392   return jresult;
31393 }
31394
31395
31396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31397   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31398   unsigned long arg2 ;
31399
31400   arg1 = (Dali::KeyEvent *)jarg1;
31401   arg2 = (unsigned long)jarg2;
31402   if (arg1) (arg1)->time = arg2;
31403 }
31404
31405
31406 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31407   unsigned long jresult ;
31408   if( jarg1 == NULL )
31409   {
31410     jresult = 0;
31411   }
31412   else
31413   {
31414     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31415     unsigned long result;
31416
31417     arg1 = ( Dali::KeyEvent * )jarg1;
31418     result = (unsigned long)( ( arg1 )->time );
31419     jresult = (unsigned long)result;
31420   }
31421   return jresult;
31422 }
31423
31424
31425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31426   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31427   Dali::KeyEvent::State arg2 ;
31428
31429   arg1 = (Dali::KeyEvent *)jarg1;
31430   arg2 = (Dali::KeyEvent::State)jarg2;
31431   if (arg1) (arg1)->state = arg2;
31432 }
31433
31434
31435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31436   int jresult ;
31437   if( jarg1 == NULL )
31438   {
31439     jresult = -1;
31440   }
31441   else
31442   {
31443     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31444     Dali::KeyEvent::State result;
31445
31446     arg1 = ( Dali::KeyEvent * )jarg1;
31447     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31448     jresult = (int)result;
31449   }
31450   return jresult;
31451 }
31452
31453
31454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31455   void * jresult ;
31456   Dali::LongPressGestureDetector *result = 0 ;
31457
31458   {
31459     try {
31460       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31461     } catch (std::out_of_range& e) {
31462       {
31463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31464       };
31465     } catch (std::exception& e) {
31466       {
31467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31468       };
31469     } catch (Dali::DaliException e) {
31470       {
31471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31472       };
31473     } catch (...) {
31474       {
31475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31476       };
31477     }
31478   }
31479
31480   jresult = (void *)result;
31481   return jresult;
31482 }
31483
31484
31485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31486   void * jresult ;
31487   Dali::LongPressGestureDetector result;
31488
31489   {
31490     try {
31491       result = Dali::LongPressGestureDetector::New();
31492     } catch (std::out_of_range& e) {
31493       {
31494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31495       };
31496     } catch (std::exception& e) {
31497       {
31498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31499       };
31500     } catch (Dali::DaliException e) {
31501       {
31502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31503       };
31504     } catch (...) {
31505       {
31506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31507       };
31508     }
31509   }
31510
31511   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31512   return jresult;
31513 }
31514
31515
31516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31517   void * jresult ;
31518   unsigned int arg1 ;
31519   Dali::LongPressGestureDetector result;
31520
31521   arg1 = (unsigned int)jarg1;
31522   {
31523     try {
31524       result = Dali::LongPressGestureDetector::New(arg1);
31525     } catch (std::out_of_range& e) {
31526       {
31527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31528       };
31529     } catch (std::exception& e) {
31530       {
31531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31532       };
31533     } catch (Dali::DaliException e) {
31534       {
31535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31536       };
31537     } catch (...) {
31538       {
31539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31540       };
31541     }
31542   }
31543
31544   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31545   return jresult;
31546 }
31547
31548
31549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31550   void * jresult ;
31551   unsigned int arg1 ;
31552   unsigned int arg2 ;
31553   Dali::LongPressGestureDetector result;
31554
31555   arg1 = (unsigned int)jarg1;
31556   arg2 = (unsigned int)jarg2;
31557   {
31558     try {
31559       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31560     } catch (std::out_of_range& e) {
31561       {
31562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31563       };
31564     } catch (std::exception& e) {
31565       {
31566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31567       };
31568     } catch (Dali::DaliException e) {
31569       {
31570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31571       };
31572     } catch (...) {
31573       {
31574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31575       };
31576     }
31577   }
31578
31579   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31580   return jresult;
31581 }
31582
31583
31584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31585   void * jresult ;
31586   Dali::BaseHandle arg1 ;
31587   Dali::BaseHandle *argp1 ;
31588   Dali::LongPressGestureDetector result;
31589
31590   argp1 = (Dali::BaseHandle *)jarg1;
31591   if (!argp1) {
31592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31593     return 0;
31594   }
31595   arg1 = *argp1;
31596   {
31597     try {
31598       result = Dali::LongPressGestureDetector::DownCast(arg1);
31599     } catch (std::out_of_range& e) {
31600       {
31601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31602       };
31603     } catch (std::exception& e) {
31604       {
31605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31606       };
31607     } catch (Dali::DaliException e) {
31608       {
31609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31610       };
31611     } catch (...) {
31612       {
31613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31614       };
31615     }
31616   }
31617
31618   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31619   return jresult;
31620 }
31621
31622
31623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31624   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31625
31626   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31627   {
31628     try {
31629       delete arg1;
31630     } catch (std::out_of_range& e) {
31631       {
31632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31633       };
31634     } catch (std::exception& e) {
31635       {
31636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31637       };
31638     } catch (Dali::DaliException e) {
31639       {
31640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31641       };
31642     } catch (...) {
31643       {
31644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31645       };
31646     }
31647   }
31648
31649 }
31650
31651
31652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31653   void * jresult ;
31654   Dali::LongPressGestureDetector *arg1 = 0 ;
31655   Dali::LongPressGestureDetector *result = 0 ;
31656
31657   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31658   if (!arg1) {
31659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31660     return 0;
31661   }
31662   {
31663     try {
31664       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31665     } catch (std::out_of_range& e) {
31666       {
31667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31668       };
31669     } catch (std::exception& e) {
31670       {
31671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31672       };
31673     } catch (Dali::DaliException e) {
31674       {
31675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31676       };
31677     } catch (...) {
31678       {
31679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31680       };
31681     }
31682   }
31683
31684   jresult = (void *)result;
31685   return jresult;
31686 }
31687
31688
31689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31690   void * jresult ;
31691   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31692   Dali::LongPressGestureDetector *arg2 = 0 ;
31693   Dali::LongPressGestureDetector *result = 0 ;
31694
31695   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31696   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31697   if (!arg2) {
31698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31699     return 0;
31700   }
31701   {
31702     try {
31703       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31704     } catch (std::out_of_range& e) {
31705       {
31706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31707       };
31708     } catch (std::exception& e) {
31709       {
31710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31711       };
31712     } catch (Dali::DaliException e) {
31713       {
31714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31715       };
31716     } catch (...) {
31717       {
31718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31719       };
31720     }
31721   }
31722
31723   jresult = (void *)result;
31724   return jresult;
31725 }
31726
31727
31728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31729   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31730   unsigned int arg2 ;
31731
31732   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31733   arg2 = (unsigned int)jarg2;
31734   {
31735     try {
31736       (arg1)->SetTouchesRequired(arg2);
31737     } catch (std::out_of_range& e) {
31738       {
31739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31740       };
31741     } catch (std::exception& e) {
31742       {
31743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31744       };
31745     } catch (Dali::DaliException e) {
31746       {
31747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31748       };
31749     } catch (...) {
31750       {
31751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31752       };
31753     }
31754   }
31755
31756 }
31757
31758
31759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31760   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31761   unsigned int arg2 ;
31762   unsigned int arg3 ;
31763
31764   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31765   arg2 = (unsigned int)jarg2;
31766   arg3 = (unsigned int)jarg3;
31767   {
31768     try {
31769       (arg1)->SetTouchesRequired(arg2,arg3);
31770     } catch (std::out_of_range& e) {
31771       {
31772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31773       };
31774     } catch (std::exception& e) {
31775       {
31776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31777       };
31778     } catch (Dali::DaliException e) {
31779       {
31780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31781       };
31782     } catch (...) {
31783       {
31784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31785       };
31786     }
31787   }
31788
31789 }
31790
31791
31792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31793   unsigned int jresult ;
31794   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31795   unsigned int result;
31796
31797   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31798   {
31799     try {
31800       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31801     } catch (std::out_of_range& e) {
31802       {
31803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31804       };
31805     } catch (std::exception& e) {
31806       {
31807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31808       };
31809     } catch (Dali::DaliException e) {
31810       {
31811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31812       };
31813     } catch (...) {
31814       {
31815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31816       };
31817     }
31818   }
31819
31820   jresult = result;
31821   return jresult;
31822 }
31823
31824
31825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31826   unsigned int jresult ;
31827   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31828   unsigned int result;
31829
31830   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31831   {
31832     try {
31833       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31834     } catch (std::out_of_range& e) {
31835       {
31836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31837       };
31838     } catch (std::exception& e) {
31839       {
31840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31841       };
31842     } catch (Dali::DaliException e) {
31843       {
31844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31845       };
31846     } catch (...) {
31847       {
31848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31849       };
31850     }
31851   }
31852
31853   jresult = result;
31854   return jresult;
31855 }
31856
31857
31858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31859   void * jresult ;
31860   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31861   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31862
31863   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31864   {
31865     try {
31866       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31867     } catch (std::out_of_range& e) {
31868       {
31869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31870       };
31871     } catch (std::exception& e) {
31872       {
31873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31874       };
31875     } catch (Dali::DaliException e) {
31876       {
31877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31878       };
31879     } catch (...) {
31880       {
31881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31882       };
31883     }
31884   }
31885
31886   jresult = (void *)result;
31887   return jresult;
31888 }
31889
31890
31891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31892   void * jresult ;
31893   Dali::Gesture::State arg1 ;
31894   Dali::LongPressGesture *result = 0 ;
31895
31896   arg1 = (Dali::Gesture::State)jarg1;
31897   {
31898     try {
31899       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31900     } catch (std::out_of_range& e) {
31901       {
31902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31903       };
31904     } catch (std::exception& e) {
31905       {
31906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31907       };
31908     } catch (Dali::DaliException e) {
31909       {
31910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31911       };
31912     } catch (...) {
31913       {
31914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31915       };
31916     }
31917   }
31918
31919   jresult = (void *)result;
31920   return jresult;
31921 }
31922
31923
31924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31925   void * jresult ;
31926   Dali::LongPressGesture *arg1 = 0 ;
31927   Dali::LongPressGesture *result = 0 ;
31928
31929   arg1 = (Dali::LongPressGesture *)jarg1;
31930   if (!arg1) {
31931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31932     return 0;
31933   }
31934   {
31935     try {
31936       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31937     } catch (std::out_of_range& e) {
31938       {
31939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31940       };
31941     } catch (std::exception& e) {
31942       {
31943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31944       };
31945     } catch (Dali::DaliException e) {
31946       {
31947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31948       };
31949     } catch (...) {
31950       {
31951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31952       };
31953     }
31954   }
31955
31956   jresult = (void *)result;
31957   return jresult;
31958 }
31959
31960
31961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31962   void * jresult ;
31963   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31964   Dali::LongPressGesture *arg2 = 0 ;
31965   Dali::LongPressGesture *result = 0 ;
31966
31967   arg1 = (Dali::LongPressGesture *)jarg1;
31968   arg2 = (Dali::LongPressGesture *)jarg2;
31969   if (!arg2) {
31970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31971     return 0;
31972   }
31973   {
31974     try {
31975       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31976     } catch (std::out_of_range& e) {
31977       {
31978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31979       };
31980     } catch (std::exception& e) {
31981       {
31982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31983       };
31984     } catch (Dali::DaliException e) {
31985       {
31986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31987       };
31988     } catch (...) {
31989       {
31990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31991       };
31992     }
31993   }
31994
31995   jresult = (void *)result;
31996   return jresult;
31997 }
31998
31999
32000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32001   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32002
32003   arg1 = (Dali::LongPressGesture *)jarg1;
32004   {
32005     try {
32006       delete arg1;
32007     } catch (std::out_of_range& e) {
32008       {
32009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32010       };
32011     } catch (std::exception& e) {
32012       {
32013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32014       };
32015     } catch (Dali::DaliException e) {
32016       {
32017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32018       };
32019     } catch (...) {
32020       {
32021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32022       };
32023     }
32024   }
32025
32026 }
32027
32028
32029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32030   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32031   unsigned int arg2 ;
32032
32033   arg1 = (Dali::LongPressGesture *)jarg1;
32034   arg2 = (unsigned int)jarg2;
32035   if (arg1) (arg1)->numberOfTouches = arg2;
32036 }
32037
32038
32039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32040   unsigned int jresult ;
32041   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32042   unsigned int result;
32043
32044   arg1 = (Dali::LongPressGesture *)jarg1;
32045   result = (unsigned int) ((arg1)->numberOfTouches);
32046   jresult = result;
32047   return jresult;
32048 }
32049
32050
32051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32052   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32053   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32054
32055   arg1 = (Dali::LongPressGesture *)jarg1;
32056   arg2 = (Dali::Vector2 *)jarg2;
32057   if (arg1) (arg1)->screenPoint = *arg2;
32058 }
32059
32060
32061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32062   void * jresult ;
32063   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32064   Dali::Vector2 *result = 0 ;
32065
32066   arg1 = (Dali::LongPressGesture *)jarg1;
32067   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32068   jresult = (void *)result;
32069   return jresult;
32070 }
32071
32072
32073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32074   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32075   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32076
32077   arg1 = (Dali::LongPressGesture *)jarg1;
32078   arg2 = (Dali::Vector2 *)jarg2;
32079   if (arg1) (arg1)->localPoint = *arg2;
32080 }
32081
32082
32083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32084   void * jresult ;
32085   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32086   Dali::Vector2 *result = 0 ;
32087
32088   arg1 = (Dali::LongPressGesture *)jarg1;
32089   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32090   jresult = (void *)result;
32091   return jresult;
32092 }
32093
32094
32095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32096   void * jresult ;
32097   Dali::WheelEvent *result = 0 ;
32098
32099   {
32100     try {
32101       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32102     } catch (std::out_of_range& e) {
32103       {
32104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32105       };
32106     } catch (std::exception& e) {
32107       {
32108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32109       };
32110     } catch (Dali::DaliException e) {
32111       {
32112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32113       };
32114     } catch (...) {
32115       {
32116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32117       };
32118     }
32119   }
32120
32121   jresult = (void *)result;
32122   return jresult;
32123 }
32124
32125
32126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32127   void * jresult ;
32128   Dali::WheelEvent::Type arg1 ;
32129   int arg2 ;
32130   unsigned int arg3 ;
32131   Dali::Vector2 arg4 ;
32132   int arg5 ;
32133   unsigned int arg6 ;
32134   Dali::Vector2 *argp4 ;
32135   Dali::WheelEvent *result = 0 ;
32136
32137   arg1 = (Dali::WheelEvent::Type)jarg1;
32138   arg2 = (int)jarg2;
32139   arg3 = (unsigned int)jarg3;
32140   argp4 = (Dali::Vector2 *)jarg4;
32141   if (!argp4) {
32142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32143     return 0;
32144   }
32145   arg4 = *argp4;
32146   arg5 = (int)jarg5;
32147   arg6 = (unsigned int)jarg6;
32148   {
32149     try {
32150       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32151     } catch (std::out_of_range& e) {
32152       {
32153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32154       };
32155     } catch (std::exception& e) {
32156       {
32157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32158       };
32159     } catch (Dali::DaliException e) {
32160       {
32161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32162       };
32163     } catch (...) {
32164       {
32165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32166       };
32167     }
32168   }
32169
32170   jresult = (void *)result;
32171   return jresult;
32172 }
32173
32174
32175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32176   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32177
32178   arg1 = (Dali::WheelEvent *)jarg1;
32179   {
32180     try {
32181       delete arg1;
32182     } catch (std::out_of_range& e) {
32183       {
32184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32185       };
32186     } catch (std::exception& e) {
32187       {
32188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32189       };
32190     } catch (Dali::DaliException e) {
32191       {
32192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32193       };
32194     } catch (...) {
32195       {
32196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32197       };
32198     }
32199   }
32200
32201 }
32202
32203
32204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32205   unsigned int jresult ;
32206   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32207   bool result;
32208
32209   arg1 = (Dali::WheelEvent *)jarg1;
32210   {
32211     try {
32212       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32213     } catch (std::out_of_range& e) {
32214       {
32215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32216       };
32217     } catch (std::exception& e) {
32218       {
32219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32220       };
32221     } catch (Dali::DaliException e) {
32222       {
32223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32224       };
32225     } catch (...) {
32226       {
32227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32228       };
32229     }
32230   }
32231
32232   jresult = result;
32233   return jresult;
32234 }
32235
32236
32237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32238   unsigned int jresult ;
32239   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32240   bool result;
32241
32242   arg1 = (Dali::WheelEvent *)jarg1;
32243   {
32244     try {
32245       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32246     } catch (std::out_of_range& e) {
32247       {
32248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32249       };
32250     } catch (std::exception& e) {
32251       {
32252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32253       };
32254     } catch (Dali::DaliException e) {
32255       {
32256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32257       };
32258     } catch (...) {
32259       {
32260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32261       };
32262     }
32263   }
32264
32265   jresult = result;
32266   return jresult;
32267 }
32268
32269
32270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32271   unsigned int jresult ;
32272   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32273   bool result;
32274
32275   arg1 = (Dali::WheelEvent *)jarg1;
32276   {
32277     try {
32278       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32279     } catch (std::out_of_range& e) {
32280       {
32281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32282       };
32283     } catch (std::exception& e) {
32284       {
32285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32286       };
32287     } catch (Dali::DaliException e) {
32288       {
32289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32290       };
32291     } catch (...) {
32292       {
32293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32294       };
32295     }
32296   }
32297
32298   jresult = result;
32299   return jresult;
32300 }
32301
32302
32303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32304   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32305   Dali::WheelEvent::Type arg2 ;
32306
32307   arg1 = (Dali::WheelEvent *)jarg1;
32308   arg2 = (Dali::WheelEvent::Type)jarg2;
32309   if (arg1) (arg1)->type = arg2;
32310 }
32311
32312
32313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32314   int jresult ;
32315   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32316   Dali::WheelEvent::Type result;
32317
32318   arg1 = (Dali::WheelEvent *)jarg1;
32319   result = (Dali::WheelEvent::Type) ((arg1)->type);
32320   jresult = (int)result;
32321   return jresult;
32322 }
32323
32324
32325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32326   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32327   int arg2 ;
32328
32329   arg1 = (Dali::WheelEvent *)jarg1;
32330   arg2 = (int)jarg2;
32331   if (arg1) (arg1)->direction = arg2;
32332 }
32333
32334
32335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32336   int jresult ;
32337   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32338   int result;
32339
32340   arg1 = (Dali::WheelEvent *)jarg1;
32341   result = (int) ((arg1)->direction);
32342   jresult = result;
32343   return jresult;
32344 }
32345
32346
32347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32348   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32349   unsigned int arg2 ;
32350
32351   arg1 = (Dali::WheelEvent *)jarg1;
32352   arg2 = (unsigned int)jarg2;
32353   if (arg1) (arg1)->modifiers = arg2;
32354 }
32355
32356
32357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32358   unsigned int jresult ;
32359   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32360   unsigned int result;
32361
32362   arg1 = (Dali::WheelEvent *)jarg1;
32363   result = (unsigned int) ((arg1)->modifiers);
32364   jresult = result;
32365   return jresult;
32366 }
32367
32368
32369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32370   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32371   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32372
32373   arg1 = (Dali::WheelEvent *)jarg1;
32374   arg2 = (Dali::Vector2 *)jarg2;
32375   if (arg1) (arg1)->point = *arg2;
32376 }
32377
32378
32379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32380   void * jresult ;
32381   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32382   Dali::Vector2 *result = 0 ;
32383
32384   arg1 = (Dali::WheelEvent *)jarg1;
32385   result = (Dali::Vector2 *)& ((arg1)->point);
32386   jresult = (void *)result;
32387   return jresult;
32388 }
32389
32390
32391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32392   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32393   int arg2 ;
32394
32395   arg1 = (Dali::WheelEvent *)jarg1;
32396   arg2 = (int)jarg2;
32397   if (arg1) (arg1)->z = arg2;
32398 }
32399
32400
32401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32402   int jresult ;
32403   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32404   int result;
32405
32406   arg1 = (Dali::WheelEvent *)jarg1;
32407   result = (int) ((arg1)->z);
32408   jresult = result;
32409   return jresult;
32410 }
32411
32412
32413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32414   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32415   unsigned int arg2 ;
32416
32417   arg1 = (Dali::WheelEvent *)jarg1;
32418   arg2 = (unsigned int)jarg2;
32419   if (arg1) (arg1)->timeStamp = arg2;
32420 }
32421
32422
32423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32424   unsigned int jresult ;
32425   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32426   unsigned int result;
32427
32428   arg1 = (Dali::WheelEvent *)jarg1;
32429   result = (unsigned int) ((arg1)->timeStamp);
32430   jresult = result;
32431   return jresult;
32432 }
32433
32434 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32435   char * jresult ;
32436   Dali::KeyEvent *arg1 = 0 ;
32437   std::string result;
32438
32439   arg1 = (Dali::KeyEvent *)jarg1;
32440   if (!arg1) {
32441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32442     return 0;
32443   }
32444   {
32445     try {
32446       result = arg1->GetDeviceName();
32447     } catch (std::out_of_range& e) {
32448       {
32449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32450       };
32451     } catch (std::exception& e) {
32452       {
32453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32454       };
32455     } catch (Dali::DaliException e) {
32456       {
32457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32458       };
32459     } catch (...) {
32460       {
32461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32462       };
32463     }
32464   }
32465
32466   jresult = SWIG_csharp_string_callback((&result)->c_str());
32467   return jresult;
32468 }
32469
32470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32471   int jresult ;
32472   Dali::KeyEvent *arg1 = 0 ;
32473   Dali::Device::Class::Type result;
32474
32475   arg1 = (Dali::KeyEvent *)jarg1;
32476   if (!arg1) {
32477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32478     return 0;
32479   }
32480   {
32481     try {
32482       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32483     } catch (std::out_of_range& e) {
32484       {
32485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32486       };
32487     } catch (std::exception& e) {
32488       {
32489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32490       };
32491     } catch (Dali::DaliException e) {
32492       {
32493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32494       };
32495     } catch (...) {
32496       {
32497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32498       };
32499     }
32500   }
32501
32502   jresult = (int)result;
32503   return jresult;
32504 }
32505
32506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32507   int jresult ;
32508   Dali::KeyEvent *arg1 = 0 ;
32509   Dali::Device::Subclass::Type result;
32510
32511   arg1 = (Dali::KeyEvent *)jarg1;
32512   if (!arg1) {
32513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32514     return 0;
32515   }
32516   {
32517     try {
32518       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32519     } catch (std::out_of_range& e) {
32520       {
32521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32522       };
32523     } catch (std::exception& e) {
32524       {
32525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32526       };
32527     } catch (Dali::DaliException e) {
32528       {
32529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32530       };
32531     } catch (...) {
32532       {
32533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32534       };
32535     }
32536   }
32537
32538   jresult = (int)result;
32539   return jresult;
32540 }
32541
32542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32543   Dali::Actor arg1 ;
32544   Dali::Actor *argp1 ;
32545
32546   argp1 = (Dali::Actor *)jarg1;
32547   if (!argp1) {
32548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32549     return ;
32550   }
32551   arg1 = *argp1;
32552   {
32553     try {
32554       arg1.Raise();
32555     } catch (std::out_of_range& e) {
32556       {
32557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32558       };
32559     } catch (std::exception& e) {
32560       {
32561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32562       };
32563     } catch (Dali::DaliException e) {
32564       {
32565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32566       };
32567     } catch (...) {
32568       {
32569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32570       };
32571     }
32572   }
32573
32574 }
32575
32576
32577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32578   Dali::Actor arg1 ;
32579   Dali::Actor *argp1 ;
32580
32581   argp1 = (Dali::Actor *)jarg1;
32582   if (!argp1) {
32583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32584     return ;
32585   }
32586   arg1 = *argp1;
32587   {
32588     try {
32589       arg1.Lower();
32590     } catch (std::out_of_range& e) {
32591       {
32592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32593       };
32594     } catch (std::exception& e) {
32595       {
32596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32597       };
32598     } catch (Dali::DaliException e) {
32599       {
32600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32601       };
32602     } catch (...) {
32603       {
32604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32605       };
32606     }
32607   }
32608
32609 }
32610
32611
32612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32613   Dali::Actor arg1 ;
32614   Dali::Actor *argp1 ;
32615
32616   argp1 = (Dali::Actor *)jarg1;
32617   if (!argp1) {
32618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32619     return ;
32620   }
32621   arg1 = *argp1;
32622   {
32623     try {
32624       arg1.RaiseToTop();
32625     } catch (std::out_of_range& e) {
32626       {
32627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32628       };
32629     } catch (std::exception& e) {
32630       {
32631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32632       };
32633     } catch (Dali::DaliException e) {
32634       {
32635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32636       };
32637     } catch (...) {
32638       {
32639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32640       };
32641     }
32642   }
32643
32644 }
32645
32646
32647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32648   Dali::Actor arg1 ;
32649   Dali::Actor *argp1 ;
32650
32651   argp1 = (Dali::Actor *)jarg1;
32652   if (!argp1) {
32653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32654     return ;
32655   }
32656   arg1 = *argp1;
32657   {
32658     try {
32659       arg1.LowerToBottom();
32660     } catch (std::out_of_range& e) {
32661       {
32662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32663       };
32664     } catch (std::exception& e) {
32665       {
32666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32667       };
32668     } catch (Dali::DaliException e) {
32669       {
32670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32671       };
32672     } catch (...) {
32673       {
32674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32675       };
32676     }
32677   }
32678
32679 }
32680
32681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32682   Dali::Actor arg1 ;
32683   Dali::Actor arg2 ;
32684   Dali::Actor *argp1 ;
32685   Dali::Actor *argp2 ;
32686
32687   argp1 = (Dali::Actor *)jarg1;
32688   if (!argp1) {
32689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32690     return ;
32691   }
32692   arg1 = *argp1;
32693   argp2 = (Dali::Actor *)jarg2;
32694   if (!argp2) {
32695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32696     return ;
32697   }
32698   arg2 = *argp2;
32699   {
32700     try {
32701       arg1.RaiseAbove(arg2);
32702     } catch (std::out_of_range& e) {
32703       {
32704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32705       };
32706     } catch (std::exception& e) {
32707       {
32708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32709       };
32710     } catch (Dali::DaliException e) {
32711       {
32712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32713       };
32714     } catch (...) {
32715       {
32716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32717       };
32718     }
32719   }
32720
32721 }
32722
32723
32724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32725   Dali::Actor arg1 ;
32726   Dali::Actor arg2 ;
32727   Dali::Actor *argp1 ;
32728   Dali::Actor *argp2 ;
32729
32730   argp1 = (Dali::Actor *)jarg1;
32731   if (!argp1) {
32732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32733     return ;
32734   }
32735   arg1 = *argp1;
32736   argp2 = (Dali::Actor *)jarg2;
32737   if (!argp2) {
32738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32739     return ;
32740   }
32741   arg2 = *argp2;
32742   {
32743     try {
32744       arg1.LowerBelow(arg2);
32745     } catch (std::out_of_range& e) {
32746       {
32747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32748       };
32749     } catch (std::exception& e) {
32750       {
32751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32752       };
32753     } catch (Dali::DaliException e) {
32754       {
32755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32756       };
32757     } catch (...) {
32758       {
32759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32760       };
32761     }
32762   }
32763
32764 }
32765
32766
32767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32768   void * jresult ;
32769   Dali::Actor arg1 ;
32770   Dali::Actor *argp1 ;
32771   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32772
32773   argp1 = (Dali::Actor *)jarg1;
32774   if (!argp1) {
32775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32776     return 0;
32777   }
32778   arg1 = *argp1;
32779   {
32780     try {
32781       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32782     } catch (std::out_of_range& e) {
32783       {
32784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32785       };
32786     } catch (std::exception& e) {
32787       {
32788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32789       };
32790     } catch (Dali::DaliException e) {
32791       {
32792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32793       };
32794     } catch (...) {
32795       {
32796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32797       };
32798     }
32799   }
32800
32801   jresult = (void *)result;
32802   return jresult;
32803 }
32804
32805
32806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32807   void * jresult ;
32808   Dali::Actor *arg1 ;
32809   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32810
32811   arg1 = (Dali::Actor *)jarg1;
32812   {
32813     try {
32814       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32815     } catch (std::out_of_range& e) {
32816       {
32817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32818       };
32819     } catch (std::exception& e) {
32820       {
32821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32822       };
32823     } catch (Dali::DaliException e) {
32824       {
32825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32826       };
32827     } catch (...) {
32828       {
32829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32830       };
32831     }
32832   }
32833
32834   jresult = (void *)result;
32835   return jresult;
32836 }
32837
32838
32839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32840   int jresult ;
32841   int result;
32842
32843   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32844   jresult = (int)result;
32845   return jresult;
32846 }
32847
32848
32849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32850   int jresult ;
32851   int result;
32852
32853   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32854   jresult = (int)result;
32855   return jresult;
32856 }
32857
32858
32859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32860   int jresult ;
32861   int result;
32862
32863   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32864   jresult = (int)result;
32865   return jresult;
32866 }
32867
32868
32869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32870   int jresult ;
32871   int result;
32872
32873   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32874   jresult = (int)result;
32875   return jresult;
32876 }
32877
32878
32879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32880   int jresult ;
32881   int result;
32882
32883   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32884   jresult = (int)result;
32885   return jresult;
32886 }
32887
32888
32889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32890   int jresult ;
32891   int result;
32892
32893   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32894   jresult = (int)result;
32895   return jresult;
32896 }
32897
32898
32899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32900   int jresult ;
32901   int result;
32902
32903   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32904   jresult = (int)result;
32905   return jresult;
32906 }
32907
32908
32909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32910   int jresult ;
32911   int result;
32912
32913   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32914   jresult = (int)result;
32915   return jresult;
32916 }
32917
32918
32919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32920   int jresult ;
32921   int result;
32922
32923   result = (int)Dali::Actor::Property::SIZE;
32924   jresult = (int)result;
32925   return jresult;
32926 }
32927
32928
32929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32930   int jresult ;
32931   int result;
32932
32933   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32934   jresult = (int)result;
32935   return jresult;
32936 }
32937
32938
32939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32940   int jresult ;
32941   int result;
32942
32943   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32944   jresult = (int)result;
32945   return jresult;
32946 }
32947
32948
32949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32950   int jresult ;
32951   int result;
32952
32953   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32954   jresult = (int)result;
32955   return jresult;
32956 }
32957
32958
32959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32960   int jresult ;
32961   int result;
32962
32963   result = (int)Dali::Actor::Property::POSITION;
32964   jresult = (int)result;
32965   return jresult;
32966 }
32967
32968
32969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32970   int jresult ;
32971   int result;
32972
32973   result = (int)Dali::Actor::Property::POSITION_X;
32974   jresult = (int)result;
32975   return jresult;
32976 }
32977
32978
32979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32980   int jresult ;
32981   int result;
32982
32983   result = (int)Dali::Actor::Property::POSITION_Y;
32984   jresult = (int)result;
32985   return jresult;
32986 }
32987
32988
32989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32990   int jresult ;
32991   int result;
32992
32993   result = (int)Dali::Actor::Property::POSITION_Z;
32994   jresult = (int)result;
32995   return jresult;
32996 }
32997
32998
32999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33000   int jresult ;
33001   int result;
33002
33003   result = (int)Dali::Actor::Property::WORLD_POSITION;
33004   jresult = (int)result;
33005   return jresult;
33006 }
33007
33008
33009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33010   int jresult ;
33011   int result;
33012
33013   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33014   jresult = (int)result;
33015   return jresult;
33016 }
33017
33018
33019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33020   int jresult ;
33021   int result;
33022
33023   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33024   jresult = (int)result;
33025   return jresult;
33026 }
33027
33028
33029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33030   int jresult ;
33031   int result;
33032
33033   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33034   jresult = (int)result;
33035   return jresult;
33036 }
33037
33038
33039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33040   int jresult ;
33041   int result;
33042
33043   result = (int)Dali::Actor::Property::ORIENTATION;
33044   jresult = (int)result;
33045   return jresult;
33046 }
33047
33048
33049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33050   int jresult ;
33051   int result;
33052
33053   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33054   jresult = (int)result;
33055   return jresult;
33056 }
33057
33058
33059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33060   int jresult ;
33061   int result;
33062
33063   result = (int)Dali::Actor::Property::SCALE;
33064   jresult = (int)result;
33065   return jresult;
33066 }
33067
33068
33069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33070   int jresult ;
33071   int result;
33072
33073   result = (int)Dali::Actor::Property::SCALE_X;
33074   jresult = (int)result;
33075   return jresult;
33076 }
33077
33078
33079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33080   int jresult ;
33081   int result;
33082
33083   result = (int)Dali::Actor::Property::SCALE_Y;
33084   jresult = (int)result;
33085   return jresult;
33086 }
33087
33088
33089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33090   int jresult ;
33091   int result;
33092
33093   result = (int)Dali::Actor::Property::SCALE_Z;
33094   jresult = (int)result;
33095   return jresult;
33096 }
33097
33098
33099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33100   int jresult ;
33101   int result;
33102
33103   result = (int)Dali::Actor::Property::WORLD_SCALE;
33104   jresult = (int)result;
33105   return jresult;
33106 }
33107
33108
33109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33110   int jresult ;
33111   int result;
33112
33113   result = (int)Dali::Actor::Property::VISIBLE;
33114   jresult = (int)result;
33115   return jresult;
33116 }
33117
33118
33119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33120   int jresult ;
33121   int result;
33122
33123   result = (int)Dali::Actor::Property::COLOR;
33124   jresult = (int)result;
33125   return jresult;
33126 }
33127
33128
33129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33130   int jresult ;
33131   int result;
33132
33133   result = (int)Dali::Actor::Property::COLOR_RED;
33134   jresult = (int)result;
33135   return jresult;
33136 }
33137
33138
33139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33140   int jresult ;
33141   int result;
33142
33143   result = (int)Dali::Actor::Property::COLOR_GREEN;
33144   jresult = (int)result;
33145   return jresult;
33146 }
33147
33148
33149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33150   int jresult ;
33151   int result;
33152
33153   result = (int)Dali::Actor::Property::COLOR_BLUE;
33154   jresult = (int)result;
33155   return jresult;
33156 }
33157
33158
33159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33160   int jresult ;
33161   int result;
33162
33163   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33164   jresult = (int)result;
33165   return jresult;
33166 }
33167
33168
33169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33170   int jresult ;
33171   int result;
33172
33173   result = (int)Dali::Actor::Property::WORLD_COLOR;
33174   jresult = (int)result;
33175   return jresult;
33176 }
33177
33178
33179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33180   int jresult ;
33181   int result;
33182
33183   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33184   jresult = (int)result;
33185   return jresult;
33186 }
33187
33188
33189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33190   int jresult ;
33191   int result;
33192
33193   result = (int)Dali::Actor::Property::NAME;
33194   jresult = (int)result;
33195   return jresult;
33196 }
33197
33198
33199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33200   int jresult ;
33201   int result;
33202
33203   result = (int)Dali::Actor::Property::SENSITIVE;
33204   jresult = (int)result;
33205   return jresult;
33206 }
33207
33208
33209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33210   int jresult ;
33211   int result;
33212
33213   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33214   jresult = (int)result;
33215   return jresult;
33216 }
33217
33218
33219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33220   int jresult ;
33221   int result;
33222
33223   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33224   jresult = (int)result;
33225   return jresult;
33226 }
33227
33228
33229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33230   int jresult ;
33231   int result;
33232
33233   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33234   jresult = (int)result;
33235   return jresult;
33236 }
33237
33238
33239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33240   int jresult ;
33241   int result;
33242
33243   result = (int)Dali::Actor::Property::COLOR_MODE;
33244   jresult = (int)result;
33245   return jresult;
33246 }
33247
33248
33249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33250   int jresult ;
33251   int result;
33252
33253   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33254   jresult = (int)result;
33255   return jresult;
33256 }
33257
33258
33259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33260   int jresult ;
33261   int result;
33262
33263   result = (int)Dali::Actor::Property::DRAW_MODE;
33264   jresult = (int)result;
33265   return jresult;
33266 }
33267
33268
33269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33270   int jresult ;
33271   int result;
33272
33273   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33274   jresult = (int)result;
33275   return jresult;
33276 }
33277
33278
33279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33280   int jresult ;
33281   int result;
33282
33283   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33284   jresult = (int)result;
33285   return jresult;
33286 }
33287
33288
33289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33290   int jresult ;
33291   int result;
33292
33293   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33294   jresult = (int)result;
33295   return jresult;
33296 }
33297
33298
33299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33300   int jresult ;
33301   int result;
33302
33303   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33304   jresult = (int)result;
33305   return jresult;
33306 }
33307
33308
33309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33310   int jresult ;
33311   int result;
33312
33313   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33314   jresult = (int)result;
33315   return jresult;
33316 }
33317
33318
33319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33320   int jresult ;
33321   int result;
33322
33323   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33324   jresult = (int)result;
33325   return jresult;
33326 }
33327
33328
33329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33330   int jresult ;
33331   int result;
33332
33333   result = (int)Dali::Actor::Property::PADDING;
33334   jresult = (int)result;
33335   return jresult;
33336 }
33337
33338
33339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33340   int jresult ;
33341   int result;
33342
33343   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33344   jresult = (int)result;
33345   return jresult;
33346 }
33347
33348
33349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33350   int jresult ;
33351   int result;
33352
33353   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33354   jresult = (int)result;
33355   return jresult;
33356 }
33357
33358
33359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33360   int jresult ;
33361   int result;
33362
33363   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33364   jresult = (int)result;
33365   return jresult;
33366 }
33367
33368
33369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33370   int jresult ;
33371   int result;
33372
33373   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33374   jresult = (int)result;
33375   return jresult;
33376 }
33377
33378
33379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33380   void * jresult ;
33381   Dali::Actor::Property *result = 0 ;
33382
33383   {
33384     try {
33385       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33386     } catch (std::out_of_range& e) {
33387       {
33388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33389       };
33390     } catch (std::exception& e) {
33391       {
33392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33393       };
33394     } catch (Dali::DaliException e) {
33395       {
33396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33397       };
33398     } catch (...) {
33399       {
33400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33401       };
33402     }
33403   }
33404
33405   jresult = (void *)result;
33406   return jresult;
33407 }
33408
33409
33410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33411   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33412
33413   arg1 = (Dali::Actor::Property *)jarg1;
33414   {
33415     try {
33416       delete arg1;
33417     } catch (std::out_of_range& e) {
33418       {
33419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33420       };
33421     } catch (std::exception& e) {
33422       {
33423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33424       };
33425     } catch (Dali::DaliException e) {
33426       {
33427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33428       };
33429     } catch (...) {
33430       {
33431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33432       };
33433     }
33434   }
33435
33436 }
33437
33438
33439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33440   void * jresult ;
33441   Dali::Actor *result = 0 ;
33442
33443   {
33444     try {
33445       result = (Dali::Actor *)new Dali::Actor();
33446     } catch (std::out_of_range& e) {
33447       {
33448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33449       };
33450     } catch (std::exception& e) {
33451       {
33452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33453       };
33454     } catch (Dali::DaliException e) {
33455       {
33456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33457       };
33458     } catch (...) {
33459       {
33460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33461       };
33462     }
33463   }
33464
33465   jresult = (void *)result;
33466   return jresult;
33467 }
33468
33469
33470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33471   void * jresult ;
33472   Dali::Actor result;
33473
33474   {
33475     try {
33476       result = Dali::Actor::New();
33477     } catch (std::out_of_range& e) {
33478       {
33479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33480       };
33481     } catch (std::exception& e) {
33482       {
33483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33484       };
33485     } catch (Dali::DaliException e) {
33486       {
33487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33488       };
33489     } catch (...) {
33490       {
33491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33492       };
33493     }
33494   }
33495
33496   jresult = new Dali::Actor((const Dali::Actor &)result);
33497   return jresult;
33498 }
33499
33500
33501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33502   void * jresult ;
33503   Dali::BaseHandle arg1 ;
33504   Dali::BaseHandle *argp1 ;
33505   Dali::Actor result;
33506
33507   argp1 = (Dali::BaseHandle *)jarg1;
33508   if (!argp1) {
33509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33510     return 0;
33511   }
33512   arg1 = *argp1;
33513   {
33514     try {
33515       result = Dali::Actor::DownCast(arg1);
33516     } catch (std::out_of_range& e) {
33517       {
33518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33519       };
33520     } catch (std::exception& e) {
33521       {
33522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33523       };
33524     } catch (Dali::DaliException e) {
33525       {
33526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33527       };
33528     } catch (...) {
33529       {
33530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33531       };
33532     }
33533   }
33534
33535   jresult = new Dali::Actor((const Dali::Actor &)result);
33536   return jresult;
33537 }
33538
33539
33540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33541   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33542
33543   arg1 = (Dali::Actor *)jarg1;
33544   {
33545     try {
33546       delete arg1;
33547     } catch (std::out_of_range& e) {
33548       {
33549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33550       };
33551     } catch (std::exception& e) {
33552       {
33553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33554       };
33555     } catch (Dali::DaliException e) {
33556       {
33557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33558       };
33559     } catch (...) {
33560       {
33561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33562       };
33563     }
33564   }
33565
33566 }
33567
33568
33569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33570   void * jresult ;
33571   Dali::Actor *arg1 = 0 ;
33572   Dali::Actor *result = 0 ;
33573
33574   arg1 = (Dali::Actor *)jarg1;
33575   if (!arg1) {
33576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33577     return 0;
33578   }
33579   {
33580     try {
33581       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33582     } catch (std::out_of_range& e) {
33583       {
33584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33585       };
33586     } catch (std::exception& e) {
33587       {
33588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33589       };
33590     } catch (Dali::DaliException e) {
33591       {
33592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33593       };
33594     } catch (...) {
33595       {
33596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33597       };
33598     }
33599   }
33600
33601   jresult = (void *)result;
33602   return jresult;
33603 }
33604
33605
33606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33607   void * jresult ;
33608   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33609   Dali::Actor *arg2 = 0 ;
33610   Dali::Actor *result = 0 ;
33611
33612   arg1 = (Dali::Actor *)jarg1;
33613   arg2 = (Dali::Actor *)jarg2;
33614   if (!arg2) {
33615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33616     return 0;
33617   }
33618   {
33619     try {
33620       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33621     } catch (std::out_of_range& e) {
33622       {
33623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33624       };
33625     } catch (std::exception& e) {
33626       {
33627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33628       };
33629     } catch (Dali::DaliException e) {
33630       {
33631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33632       };
33633     } catch (...) {
33634       {
33635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33636       };
33637     }
33638   }
33639
33640   jresult = (void *)result;
33641   return jresult;
33642 }
33643
33644
33645 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33646   char * jresult ;
33647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33648   std::string *result = 0 ;
33649
33650   arg1 = (Dali::Actor *)jarg1;
33651   {
33652     try {
33653       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33654     } catch (std::out_of_range& e) {
33655       {
33656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33657       };
33658     } catch (std::exception& e) {
33659       {
33660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33661       };
33662     } catch (Dali::DaliException e) {
33663       {
33664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33665       };
33666     } catch (...) {
33667       {
33668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33669       };
33670     }
33671   }
33672
33673   jresult = SWIG_csharp_string_callback(result->c_str());
33674   return jresult;
33675 }
33676
33677
33678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33679   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33680   std::string *arg2 = 0 ;
33681
33682   arg1 = (Dali::Actor *)jarg1;
33683   if (!jarg2) {
33684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33685     return ;
33686   }
33687   std::string arg2_str(jarg2);
33688   arg2 = &arg2_str;
33689   {
33690     try {
33691       (arg1)->SetName((std::string const &)*arg2);
33692     } catch (std::out_of_range& e) {
33693       {
33694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33695       };
33696     } catch (std::exception& e) {
33697       {
33698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33699       };
33700     } catch (Dali::DaliException e) {
33701       {
33702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33703       };
33704     } catch (...) {
33705       {
33706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33707       };
33708     }
33709   }
33710
33711
33712   //argout typemap for const std::string&
33713
33714 }
33715
33716
33717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33718   unsigned int jresult ;
33719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33720   unsigned int result;
33721
33722   arg1 = (Dali::Actor *)jarg1;
33723   {
33724     try {
33725       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33726     } catch (std::out_of_range& e) {
33727       {
33728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33729       };
33730     } catch (std::exception& e) {
33731       {
33732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33733       };
33734     } catch (Dali::DaliException e) {
33735       {
33736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33737       };
33738     } catch (...) {
33739       {
33740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33741       };
33742     }
33743   }
33744
33745   jresult = result;
33746   return jresult;
33747 }
33748
33749
33750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33751   unsigned int jresult ;
33752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33753   bool result;
33754
33755   arg1 = (Dali::Actor *)jarg1;
33756   {
33757     try {
33758       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33759     } catch (std::out_of_range& e) {
33760       {
33761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33762       };
33763     } catch (std::exception& e) {
33764       {
33765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33766       };
33767     } catch (Dali::DaliException e) {
33768       {
33769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33770       };
33771     } catch (...) {
33772       {
33773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33774       };
33775     }
33776   }
33777
33778   jresult = result;
33779   return jresult;
33780 }
33781
33782
33783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33784   unsigned int jresult ;
33785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33786   bool result;
33787
33788   arg1 = (Dali::Actor *)jarg1;
33789   {
33790     try {
33791       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33792     } catch (std::out_of_range& e) {
33793       {
33794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33795       };
33796     } catch (std::exception& e) {
33797       {
33798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33799       };
33800     } catch (Dali::DaliException e) {
33801       {
33802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33803       };
33804     } catch (...) {
33805       {
33806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33807       };
33808     }
33809   }
33810
33811   jresult = result;
33812   return jresult;
33813 }
33814
33815
33816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33817   unsigned int jresult ;
33818   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33819   bool result;
33820
33821   arg1 = (Dali::Actor *)jarg1;
33822   {
33823     try {
33824       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33825     } catch (std::out_of_range& e) {
33826       {
33827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33828       };
33829     } catch (std::exception& e) {
33830       {
33831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33832       };
33833     } catch (Dali::DaliException e) {
33834       {
33835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33836       };
33837     } catch (...) {
33838       {
33839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33840       };
33841     }
33842   }
33843
33844   jresult = result;
33845   return jresult;
33846 }
33847
33848
33849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33850   void * jresult ;
33851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33852   Dali::Layer result;
33853
33854   arg1 = (Dali::Actor *)jarg1;
33855   {
33856     try {
33857       result = (arg1)->GetLayer();
33858     } catch (std::out_of_range& e) {
33859       {
33860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33861       };
33862     } catch (std::exception& e) {
33863       {
33864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33865       };
33866     } catch (Dali::DaliException e) {
33867       {
33868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33869       };
33870     } catch (...) {
33871       {
33872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33873       };
33874     }
33875   }
33876
33877   jresult = new Dali::Layer((const Dali::Layer &)result);
33878   return jresult;
33879 }
33880
33881
33882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33883   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33884   Dali::Actor arg2 ;
33885   Dali::Actor *argp2 ;
33886
33887   arg1 = (Dali::Actor *)jarg1;
33888   argp2 = (Dali::Actor *)jarg2;
33889   if (!argp2) {
33890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33891     return ;
33892   }
33893   arg2 = *argp2;
33894   {
33895     try {
33896       (arg1)->Add(arg2);
33897     } catch (std::out_of_range& e) {
33898       {
33899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33900       };
33901     } catch (std::exception& e) {
33902       {
33903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33904       };
33905     } catch (Dali::DaliException e) {
33906       {
33907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33908       };
33909     } catch (...) {
33910       {
33911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33912       };
33913     }
33914   }
33915
33916 }
33917
33918
33919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33920   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33921   Dali::Actor arg2 ;
33922   Dali::Actor *argp2 ;
33923
33924   arg1 = (Dali::Actor *)jarg1;
33925   argp2 = (Dali::Actor *)jarg2;
33926   if (!argp2) {
33927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33928     return ;
33929   }
33930   arg2 = *argp2;
33931   {
33932     try {
33933       (arg1)->Remove(arg2);
33934     } catch (std::out_of_range& e) {
33935       {
33936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33937       };
33938     } catch (std::exception& e) {
33939       {
33940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33941       };
33942     } catch (Dali::DaliException e) {
33943       {
33944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33945       };
33946     } catch (...) {
33947       {
33948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33949       };
33950     }
33951   }
33952
33953 }
33954
33955
33956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33957   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33958
33959   arg1 = (Dali::Actor *)jarg1;
33960   {
33961     try {
33962       (arg1)->Unparent();
33963     } catch (std::out_of_range& e) {
33964       {
33965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33966       };
33967     } catch (std::exception& e) {
33968       {
33969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33970       };
33971     } catch (Dali::DaliException e) {
33972       {
33973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33974       };
33975     } catch (...) {
33976       {
33977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33978       };
33979     }
33980   }
33981
33982 }
33983
33984
33985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33986   unsigned int jresult ;
33987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33988   unsigned int result;
33989
33990   arg1 = (Dali::Actor *)jarg1;
33991   {
33992     try {
33993       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33994     } catch (std::out_of_range& e) {
33995       {
33996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33997       };
33998     } catch (std::exception& e) {
33999       {
34000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34001       };
34002     } catch (Dali::DaliException e) {
34003       {
34004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34005       };
34006     } catch (...) {
34007       {
34008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34009       };
34010     }
34011   }
34012
34013   jresult = result;
34014   return jresult;
34015 }
34016
34017
34018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34019   void * jresult ;
34020   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34021   unsigned int arg2 ;
34022   Dali::Actor result;
34023
34024   arg1 = (Dali::Actor *)jarg1;
34025   arg2 = (unsigned int)jarg2;
34026   {
34027     try {
34028       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34029     } catch (std::out_of_range& e) {
34030       {
34031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34032       };
34033     } catch (std::exception& e) {
34034       {
34035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34036       };
34037     } catch (Dali::DaliException e) {
34038       {
34039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34040       };
34041     } catch (...) {
34042       {
34043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34044       };
34045     }
34046   }
34047
34048   jresult = new Dali::Actor((const Dali::Actor &)result);
34049   return jresult;
34050 }
34051
34052
34053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34054   void * jresult ;
34055   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34056   std::string *arg2 = 0 ;
34057   Dali::Actor result;
34058
34059   arg1 = (Dali::Actor *)jarg1;
34060   if (!jarg2) {
34061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34062     return 0;
34063   }
34064   std::string arg2_str(jarg2);
34065   arg2 = &arg2_str;
34066   {
34067     try {
34068       result = (arg1)->FindChildByName((std::string const &)*arg2);
34069     } catch (std::out_of_range& e) {
34070       {
34071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34072       };
34073     } catch (std::exception& e) {
34074       {
34075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34076       };
34077     } catch (Dali::DaliException e) {
34078       {
34079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34080       };
34081     } catch (...) {
34082       {
34083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34084       };
34085     }
34086   }
34087
34088   jresult = new Dali::Actor((const Dali::Actor &)result);
34089
34090   //argout typemap for const std::string&
34091
34092   return jresult;
34093 }
34094
34095
34096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34097   void * jresult ;
34098   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34099   unsigned int arg2 ;
34100   Dali::Actor result;
34101
34102   arg1 = (Dali::Actor *)jarg1;
34103   arg2 = (unsigned int)jarg2;
34104   {
34105     try {
34106       result = (arg1)->FindChildById(arg2);
34107     } catch (std::out_of_range& e) {
34108       {
34109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34110       };
34111     } catch (std::exception& e) {
34112       {
34113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34114       };
34115     } catch (Dali::DaliException e) {
34116       {
34117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34118       };
34119     } catch (...) {
34120       {
34121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34122       };
34123     }
34124   }
34125
34126   jresult = new Dali::Actor((const Dali::Actor &)result);
34127   return jresult;
34128 }
34129
34130
34131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34132   void * jresult ;
34133   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34134   Dali::Actor result;
34135
34136   arg1 = (Dali::Actor *)jarg1;
34137   {
34138     try {
34139       result = ((Dali::Actor const *)arg1)->GetParent();
34140     } catch (std::out_of_range& e) {
34141       {
34142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34143       };
34144     } catch (std::exception& e) {
34145       {
34146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34147       };
34148     } catch (Dali::DaliException e) {
34149       {
34150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34151       };
34152     } catch (...) {
34153       {
34154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34155       };
34156     }
34157   }
34158
34159   jresult = new Dali::Actor((const Dali::Actor &)result);
34160   return jresult;
34161 }
34162
34163
34164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34165   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34166   Dali::Vector3 *arg2 = 0 ;
34167
34168   arg1 = (Dali::Actor *)jarg1;
34169   arg2 = (Dali::Vector3 *)jarg2;
34170   if (!arg2) {
34171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34172     return ;
34173   }
34174   {
34175     try {
34176       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34177     } catch (std::out_of_range& e) {
34178       {
34179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34180       };
34181     } catch (std::exception& e) {
34182       {
34183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34184       };
34185     } catch (Dali::DaliException e) {
34186       {
34187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34188       };
34189     } catch (...) {
34190       {
34191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34192       };
34193     }
34194   }
34195
34196 }
34197
34198
34199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34200   void * jresult ;
34201   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34202   Dali::Vector3 result;
34203
34204   arg1 = (Dali::Actor *)jarg1;
34205   {
34206     try {
34207       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34208     } catch (std::out_of_range& e) {
34209       {
34210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34211       };
34212     } catch (std::exception& e) {
34213       {
34214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34215       };
34216     } catch (Dali::DaliException e) {
34217       {
34218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34219       };
34220     } catch (...) {
34221       {
34222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34223       };
34224     }
34225   }
34226
34227   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34228   return jresult;
34229 }
34230
34231
34232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34233   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34234   Dali::Vector3 *arg2 = 0 ;
34235
34236   arg1 = (Dali::Actor *)jarg1;
34237   arg2 = (Dali::Vector3 *)jarg2;
34238   if (!arg2) {
34239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34240     return ;
34241   }
34242   {
34243     try {
34244       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34245     } catch (std::out_of_range& e) {
34246       {
34247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34248       };
34249     } catch (std::exception& e) {
34250       {
34251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34252       };
34253     } catch (Dali::DaliException e) {
34254       {
34255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34256       };
34257     } catch (...) {
34258       {
34259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34260       };
34261     }
34262   }
34263
34264 }
34265
34266
34267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34268   void * jresult ;
34269   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34270   Dali::Vector3 result;
34271
34272   arg1 = (Dali::Actor *)jarg1;
34273   {
34274     try {
34275       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34276     } catch (std::out_of_range& e) {
34277       {
34278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34279       };
34280     } catch (std::exception& e) {
34281       {
34282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34283       };
34284     } catch (Dali::DaliException e) {
34285       {
34286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34287       };
34288     } catch (...) {
34289       {
34290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34291       };
34292     }
34293   }
34294
34295   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34296   return jresult;
34297 }
34298
34299
34300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34301   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34302   float arg2 ;
34303   float arg3 ;
34304
34305   arg1 = (Dali::Actor *)jarg1;
34306   arg2 = (float)jarg2;
34307   arg3 = (float)jarg3;
34308   {
34309     try {
34310       (arg1)->SetSize(arg2,arg3);
34311     } catch (std::out_of_range& e) {
34312       {
34313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34314       };
34315     } catch (std::exception& e) {
34316       {
34317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34318       };
34319     } catch (Dali::DaliException e) {
34320       {
34321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34322       };
34323     } catch (...) {
34324       {
34325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34326       };
34327     }
34328   }
34329
34330 }
34331
34332
34333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34334   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34335   float arg2 ;
34336   float arg3 ;
34337   float arg4 ;
34338
34339   arg1 = (Dali::Actor *)jarg1;
34340   arg2 = (float)jarg2;
34341   arg3 = (float)jarg3;
34342   arg4 = (float)jarg4;
34343   {
34344     try {
34345       (arg1)->SetSize(arg2,arg3,arg4);
34346     } catch (std::out_of_range& e) {
34347       {
34348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34349       };
34350     } catch (std::exception& e) {
34351       {
34352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34353       };
34354     } catch (Dali::DaliException e) {
34355       {
34356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34357       };
34358     } catch (...) {
34359       {
34360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34361       };
34362     }
34363   }
34364
34365 }
34366
34367
34368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34369   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34370   Dali::Vector2 *arg2 = 0 ;
34371
34372   arg1 = (Dali::Actor *)jarg1;
34373   arg2 = (Dali::Vector2 *)jarg2;
34374   if (!arg2) {
34375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34376     return ;
34377   }
34378   {
34379     try {
34380       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34381     } catch (std::out_of_range& e) {
34382       {
34383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34384       };
34385     } catch (std::exception& e) {
34386       {
34387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34388       };
34389     } catch (Dali::DaliException e) {
34390       {
34391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34392       };
34393     } catch (...) {
34394       {
34395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34396       };
34397     }
34398   }
34399
34400 }
34401
34402
34403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34404   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34405   Dali::Vector3 *arg2 = 0 ;
34406
34407   arg1 = (Dali::Actor *)jarg1;
34408   arg2 = (Dali::Vector3 *)jarg2;
34409   if (!arg2) {
34410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34411     return ;
34412   }
34413   {
34414     try {
34415       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34416     } catch (std::out_of_range& e) {
34417       {
34418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34419       };
34420     } catch (std::exception& e) {
34421       {
34422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34423       };
34424     } catch (Dali::DaliException e) {
34425       {
34426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34427       };
34428     } catch (...) {
34429       {
34430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34431       };
34432     }
34433   }
34434
34435 }
34436
34437
34438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34439   void * jresult ;
34440   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34441   Dali::Vector3 result;
34442
34443   arg1 = (Dali::Actor *)jarg1;
34444   {
34445     try {
34446       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34447     } catch (std::out_of_range& e) {
34448       {
34449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34450       };
34451     } catch (std::exception& e) {
34452       {
34453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34454       };
34455     } catch (Dali::DaliException e) {
34456       {
34457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34458       };
34459     } catch (...) {
34460       {
34461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34462       };
34463     }
34464   }
34465
34466   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34467   return jresult;
34468 }
34469
34470
34471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34472   void * jresult ;
34473   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34474   Dali::Vector3 result;
34475
34476   arg1 = (Dali::Actor *)jarg1;
34477   {
34478     try {
34479       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34480     } catch (std::out_of_range& e) {
34481       {
34482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34483       };
34484     } catch (std::exception& e) {
34485       {
34486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34487       };
34488     } catch (Dali::DaliException e) {
34489       {
34490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34491       };
34492     } catch (...) {
34493       {
34494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34495       };
34496     }
34497   }
34498
34499   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34500   return jresult;
34501 }
34502
34503
34504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34505   void * jresult ;
34506   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34507   Dali::Vector3 result;
34508
34509   arg1 = (Dali::Actor *)jarg1;
34510   {
34511     try {
34512       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34513     } catch (std::out_of_range& e) {
34514       {
34515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34516       };
34517     } catch (std::exception& e) {
34518       {
34519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34520       };
34521     } catch (Dali::DaliException e) {
34522       {
34523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34524       };
34525     } catch (...) {
34526       {
34527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34528       };
34529     }
34530   }
34531
34532   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34533   return jresult;
34534 }
34535
34536
34537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34538   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34539   float arg2 ;
34540   float arg3 ;
34541
34542   arg1 = (Dali::Actor *)jarg1;
34543   arg2 = (float)jarg2;
34544   arg3 = (float)jarg3;
34545   {
34546     try {
34547       (arg1)->SetPosition(arg2,arg3);
34548     } catch (std::out_of_range& e) {
34549       {
34550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34551       };
34552     } catch (std::exception& e) {
34553       {
34554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34555       };
34556     } catch (Dali::DaliException e) {
34557       {
34558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34559       };
34560     } catch (...) {
34561       {
34562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34563       };
34564     }
34565   }
34566
34567 }
34568
34569
34570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34571   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34572   float arg2 ;
34573   float arg3 ;
34574   float arg4 ;
34575
34576   arg1 = (Dali::Actor *)jarg1;
34577   arg2 = (float)jarg2;
34578   arg3 = (float)jarg3;
34579   arg4 = (float)jarg4;
34580   {
34581     try {
34582       (arg1)->SetPosition(arg2,arg3,arg4);
34583     } catch (std::out_of_range& e) {
34584       {
34585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34586       };
34587     } catch (std::exception& e) {
34588       {
34589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34590       };
34591     } catch (Dali::DaliException e) {
34592       {
34593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34594       };
34595     } catch (...) {
34596       {
34597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34598       };
34599     }
34600   }
34601
34602 }
34603
34604
34605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34606   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34607   Dali::Vector3 *arg2 = 0 ;
34608
34609   arg1 = (Dali::Actor *)jarg1;
34610   arg2 = (Dali::Vector3 *)jarg2;
34611   if (!arg2) {
34612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34613     return ;
34614   }
34615   {
34616     try {
34617       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34618     } catch (std::out_of_range& e) {
34619       {
34620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34621       };
34622     } catch (std::exception& e) {
34623       {
34624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34625       };
34626     } catch (Dali::DaliException e) {
34627       {
34628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34629       };
34630     } catch (...) {
34631       {
34632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34633       };
34634     }
34635   }
34636
34637 }
34638
34639
34640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34641   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34642   float arg2 ;
34643
34644   arg1 = (Dali::Actor *)jarg1;
34645   arg2 = (float)jarg2;
34646   {
34647     try {
34648       (arg1)->SetX(arg2);
34649     } catch (std::out_of_range& e) {
34650       {
34651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34652       };
34653     } catch (std::exception& e) {
34654       {
34655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34656       };
34657     } catch (Dali::DaliException e) {
34658       {
34659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34660       };
34661     } catch (...) {
34662       {
34663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34664       };
34665     }
34666   }
34667
34668 }
34669
34670
34671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34672   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34673   float arg2 ;
34674
34675   arg1 = (Dali::Actor *)jarg1;
34676   arg2 = (float)jarg2;
34677   {
34678     try {
34679       (arg1)->SetY(arg2);
34680     } catch (std::out_of_range& e) {
34681       {
34682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34683       };
34684     } catch (std::exception& e) {
34685       {
34686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34687       };
34688     } catch (Dali::DaliException e) {
34689       {
34690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34691       };
34692     } catch (...) {
34693       {
34694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34695       };
34696     }
34697   }
34698
34699 }
34700
34701
34702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34703   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34704   float arg2 ;
34705
34706   arg1 = (Dali::Actor *)jarg1;
34707   arg2 = (float)jarg2;
34708   {
34709     try {
34710       (arg1)->SetZ(arg2);
34711     } catch (std::out_of_range& e) {
34712       {
34713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34714       };
34715     } catch (std::exception& e) {
34716       {
34717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34718       };
34719     } catch (Dali::DaliException e) {
34720       {
34721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34722       };
34723     } catch (...) {
34724       {
34725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34726       };
34727     }
34728   }
34729
34730 }
34731
34732
34733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34734   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34735   Dali::Vector3 *arg2 = 0 ;
34736
34737   arg1 = (Dali::Actor *)jarg1;
34738   arg2 = (Dali::Vector3 *)jarg2;
34739   if (!arg2) {
34740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34741     return ;
34742   }
34743   {
34744     try {
34745       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34746     } catch (std::out_of_range& e) {
34747       {
34748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34749       };
34750     } catch (std::exception& e) {
34751       {
34752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34753       };
34754     } catch (Dali::DaliException e) {
34755       {
34756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34757       };
34758     } catch (...) {
34759       {
34760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34761       };
34762     }
34763   }
34764
34765 }
34766
34767
34768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34769   void * jresult ;
34770   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34771   Dali::Vector3 result;
34772
34773   arg1 = (Dali::Actor *)jarg1;
34774   {
34775     try {
34776       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34777     } catch (std::out_of_range& e) {
34778       {
34779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34780       };
34781     } catch (std::exception& e) {
34782       {
34783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34784       };
34785     } catch (Dali::DaliException e) {
34786       {
34787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34788       };
34789     } catch (...) {
34790       {
34791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34792       };
34793     }
34794   }
34795
34796   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34797   return jresult;
34798 }
34799
34800
34801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34802   void * jresult ;
34803   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34804   Dali::Vector3 result;
34805
34806   arg1 = (Dali::Actor *)jarg1;
34807   {
34808     try {
34809       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34810     } catch (std::out_of_range& e) {
34811       {
34812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34813       };
34814     } catch (std::exception& e) {
34815       {
34816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34817       };
34818     } catch (Dali::DaliException e) {
34819       {
34820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34821       };
34822     } catch (...) {
34823       {
34824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34825       };
34826     }
34827   }
34828
34829   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34830   return jresult;
34831 }
34832
34833
34834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34835   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34836   bool arg2 ;
34837
34838   arg1 = (Dali::Actor *)jarg1;
34839   arg2 = jarg2 ? true : false;
34840   {
34841     try {
34842       (arg1)->SetInheritPosition(arg2);
34843     } catch (std::out_of_range& e) {
34844       {
34845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34846       };
34847     } catch (std::exception& e) {
34848       {
34849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34850       };
34851     } catch (Dali::DaliException e) {
34852       {
34853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34854       };
34855     } catch (...) {
34856       {
34857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34858       };
34859     }
34860   }
34861
34862 }
34863
34864
34865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34866   int jresult ;
34867   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34868   Dali::PositionInheritanceMode result;
34869
34870   arg1 = (Dali::Actor *)jarg1;
34871   {
34872     try {
34873       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34874     } catch (std::out_of_range& e) {
34875       {
34876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34877       };
34878     } catch (std::exception& e) {
34879       {
34880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34881       };
34882     } catch (Dali::DaliException e) {
34883       {
34884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34885       };
34886     } catch (...) {
34887       {
34888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34889       };
34890     }
34891   }
34892
34893   jresult = (int)result;
34894   return jresult;
34895 }
34896
34897
34898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34899   unsigned int jresult ;
34900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34901   bool result;
34902
34903   arg1 = (Dali::Actor *)jarg1;
34904   {
34905     try {
34906       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34907     } catch (std::out_of_range& e) {
34908       {
34909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34910       };
34911     } catch (std::exception& e) {
34912       {
34913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34914       };
34915     } catch (Dali::DaliException e) {
34916       {
34917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34918       };
34919     } catch (...) {
34920       {
34921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34922       };
34923     }
34924   }
34925
34926   jresult = result;
34927   return jresult;
34928 }
34929
34930
34931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34932   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34933   Dali::Degree *arg2 = 0 ;
34934   Dali::Vector3 *arg3 = 0 ;
34935
34936   arg1 = (Dali::Actor *)jarg1;
34937   arg2 = (Dali::Degree *)jarg2;
34938   if (!arg2) {
34939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34940     return ;
34941   }
34942   arg3 = (Dali::Vector3 *)jarg3;
34943   if (!arg3) {
34944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34945     return ;
34946   }
34947   {
34948     try {
34949       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34950     } catch (std::out_of_range& e) {
34951       {
34952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34953       };
34954     } catch (std::exception& e) {
34955       {
34956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34957       };
34958     } catch (Dali::DaliException e) {
34959       {
34960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34961       };
34962     } catch (...) {
34963       {
34964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34965       };
34966     }
34967   }
34968
34969 }
34970
34971
34972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34973   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34974   Dali::Radian *arg2 = 0 ;
34975   Dali::Vector3 *arg3 = 0 ;
34976
34977   arg1 = (Dali::Actor *)jarg1;
34978   arg2 = (Dali::Radian *)jarg2;
34979   if (!arg2) {
34980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34981     return ;
34982   }
34983   arg3 = (Dali::Vector3 *)jarg3;
34984   if (!arg3) {
34985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34986     return ;
34987   }
34988   {
34989     try {
34990       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34991     } catch (std::out_of_range& e) {
34992       {
34993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34994       };
34995     } catch (std::exception& e) {
34996       {
34997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34998       };
34999     } catch (Dali::DaliException e) {
35000       {
35001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35002       };
35003     } catch (...) {
35004       {
35005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35006       };
35007     }
35008   }
35009
35010 }
35011
35012
35013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35015   Dali::Quaternion *arg2 = 0 ;
35016
35017   arg1 = (Dali::Actor *)jarg1;
35018   arg2 = (Dali::Quaternion *)jarg2;
35019   if (!arg2) {
35020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35021     return ;
35022   }
35023   {
35024     try {
35025       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35026     } catch (std::out_of_range& e) {
35027       {
35028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35029       };
35030     } catch (std::exception& e) {
35031       {
35032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35033       };
35034     } catch (Dali::DaliException e) {
35035       {
35036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35037       };
35038     } catch (...) {
35039       {
35040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35041       };
35042     }
35043   }
35044
35045 }
35046
35047
35048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35050   Dali::Degree *arg2 = 0 ;
35051   Dali::Vector3 *arg3 = 0 ;
35052
35053   arg1 = (Dali::Actor *)jarg1;
35054   arg2 = (Dali::Degree *)jarg2;
35055   if (!arg2) {
35056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35057     return ;
35058   }
35059   arg3 = (Dali::Vector3 *)jarg3;
35060   if (!arg3) {
35061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35062     return ;
35063   }
35064   {
35065     try {
35066       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35067     } catch (std::out_of_range& e) {
35068       {
35069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35070       };
35071     } catch (std::exception& e) {
35072       {
35073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35074       };
35075     } catch (Dali::DaliException e) {
35076       {
35077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35078       };
35079     } catch (...) {
35080       {
35081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35082       };
35083     }
35084   }
35085
35086 }
35087
35088
35089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35091   Dali::Radian *arg2 = 0 ;
35092   Dali::Vector3 *arg3 = 0 ;
35093
35094   arg1 = (Dali::Actor *)jarg1;
35095   arg2 = (Dali::Radian *)jarg2;
35096   if (!arg2) {
35097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35098     return ;
35099   }
35100   arg3 = (Dali::Vector3 *)jarg3;
35101   if (!arg3) {
35102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35103     return ;
35104   }
35105   {
35106     try {
35107       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35108     } catch (std::out_of_range& e) {
35109       {
35110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35111       };
35112     } catch (std::exception& e) {
35113       {
35114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35115       };
35116     } catch (Dali::DaliException e) {
35117       {
35118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35119       };
35120     } catch (...) {
35121       {
35122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35123       };
35124     }
35125   }
35126
35127 }
35128
35129
35130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35132   Dali::Quaternion *arg2 = 0 ;
35133
35134   arg1 = (Dali::Actor *)jarg1;
35135   arg2 = (Dali::Quaternion *)jarg2;
35136   if (!arg2) {
35137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35138     return ;
35139   }
35140   {
35141     try {
35142       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35143     } catch (std::out_of_range& e) {
35144       {
35145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35146       };
35147     } catch (std::exception& e) {
35148       {
35149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35150       };
35151     } catch (Dali::DaliException e) {
35152       {
35153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35154       };
35155     } catch (...) {
35156       {
35157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35158       };
35159     }
35160   }
35161
35162 }
35163
35164
35165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35166   void * jresult ;
35167   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35168   Dali::Quaternion result;
35169
35170   arg1 = (Dali::Actor *)jarg1;
35171   {
35172     try {
35173       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35174     } catch (std::out_of_range& e) {
35175       {
35176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35177       };
35178     } catch (std::exception& e) {
35179       {
35180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35181       };
35182     } catch (Dali::DaliException e) {
35183       {
35184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35185       };
35186     } catch (...) {
35187       {
35188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35189       };
35190     }
35191   }
35192
35193   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35194   return jresult;
35195 }
35196
35197
35198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35199   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35200   bool arg2 ;
35201
35202   arg1 = (Dali::Actor *)jarg1;
35203   arg2 = jarg2 ? true : false;
35204   {
35205     try {
35206       (arg1)->SetInheritOrientation(arg2);
35207     } catch (std::out_of_range& e) {
35208       {
35209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35210       };
35211     } catch (std::exception& e) {
35212       {
35213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35214       };
35215     } catch (Dali::DaliException e) {
35216       {
35217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35218       };
35219     } catch (...) {
35220       {
35221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35222       };
35223     }
35224   }
35225
35226 }
35227
35228
35229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35230   unsigned int jresult ;
35231   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35232   bool result;
35233
35234   arg1 = (Dali::Actor *)jarg1;
35235   {
35236     try {
35237       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35238     } catch (std::out_of_range& e) {
35239       {
35240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35241       };
35242     } catch (std::exception& e) {
35243       {
35244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35245       };
35246     } catch (Dali::DaliException e) {
35247       {
35248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35249       };
35250     } catch (...) {
35251       {
35252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35253       };
35254     }
35255   }
35256
35257   jresult = result;
35258   return jresult;
35259 }
35260
35261
35262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35263   void * jresult ;
35264   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35265   Dali::Quaternion result;
35266
35267   arg1 = (Dali::Actor *)jarg1;
35268   {
35269     try {
35270       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35271     } catch (std::out_of_range& e) {
35272       {
35273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35274       };
35275     } catch (std::exception& e) {
35276       {
35277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35278       };
35279     } catch (Dali::DaliException e) {
35280       {
35281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35282       };
35283     } catch (...) {
35284       {
35285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35286       };
35287     }
35288   }
35289
35290   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35291   return jresult;
35292 }
35293
35294
35295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35296   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35297   float arg2 ;
35298
35299   arg1 = (Dali::Actor *)jarg1;
35300   arg2 = (float)jarg2;
35301   {
35302     try {
35303       (arg1)->SetScale(arg2);
35304     } catch (std::out_of_range& e) {
35305       {
35306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35307       };
35308     } catch (std::exception& e) {
35309       {
35310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35311       };
35312     } catch (Dali::DaliException e) {
35313       {
35314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35315       };
35316     } catch (...) {
35317       {
35318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35319       };
35320     }
35321   }
35322
35323 }
35324
35325
35326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35328   float arg2 ;
35329   float arg3 ;
35330   float arg4 ;
35331
35332   arg1 = (Dali::Actor *)jarg1;
35333   arg2 = (float)jarg2;
35334   arg3 = (float)jarg3;
35335   arg4 = (float)jarg4;
35336   {
35337     try {
35338       (arg1)->SetScale(arg2,arg3,arg4);
35339     } catch (std::out_of_range& e) {
35340       {
35341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35342       };
35343     } catch (std::exception& e) {
35344       {
35345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35346       };
35347     } catch (Dali::DaliException e) {
35348       {
35349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35350       };
35351     } catch (...) {
35352       {
35353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35354       };
35355     }
35356   }
35357
35358 }
35359
35360
35361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35362   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35363   Dali::Vector3 *arg2 = 0 ;
35364
35365   arg1 = (Dali::Actor *)jarg1;
35366   arg2 = (Dali::Vector3 *)jarg2;
35367   if (!arg2) {
35368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35369     return ;
35370   }
35371   {
35372     try {
35373       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35374     } catch (std::out_of_range& e) {
35375       {
35376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35377       };
35378     } catch (std::exception& e) {
35379       {
35380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35381       };
35382     } catch (Dali::DaliException e) {
35383       {
35384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35385       };
35386     } catch (...) {
35387       {
35388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35389       };
35390     }
35391   }
35392
35393 }
35394
35395
35396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35397   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35398   Dali::Vector3 *arg2 = 0 ;
35399
35400   arg1 = (Dali::Actor *)jarg1;
35401   arg2 = (Dali::Vector3 *)jarg2;
35402   if (!arg2) {
35403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35404     return ;
35405   }
35406   {
35407     try {
35408       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35409     } catch (std::out_of_range& e) {
35410       {
35411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35412       };
35413     } catch (std::exception& e) {
35414       {
35415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35416       };
35417     } catch (Dali::DaliException e) {
35418       {
35419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35420       };
35421     } catch (...) {
35422       {
35423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35424       };
35425     }
35426   }
35427
35428 }
35429
35430
35431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35432   void * jresult ;
35433   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35434   Dali::Vector3 result;
35435
35436   arg1 = (Dali::Actor *)jarg1;
35437   {
35438     try {
35439       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35440     } catch (std::out_of_range& e) {
35441       {
35442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35443       };
35444     } catch (std::exception& e) {
35445       {
35446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35447       };
35448     } catch (Dali::DaliException e) {
35449       {
35450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35451       };
35452     } catch (...) {
35453       {
35454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35455       };
35456     }
35457   }
35458
35459   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35460   return jresult;
35461 }
35462
35463
35464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35465   void * jresult ;
35466   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35467   Dali::Vector3 result;
35468
35469   arg1 = (Dali::Actor *)jarg1;
35470   {
35471     try {
35472       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35473     } catch (std::out_of_range& e) {
35474       {
35475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35476       };
35477     } catch (std::exception& e) {
35478       {
35479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35480       };
35481     } catch (Dali::DaliException e) {
35482       {
35483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35484       };
35485     } catch (...) {
35486       {
35487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35488       };
35489     }
35490   }
35491
35492   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35493   return jresult;
35494 }
35495
35496
35497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35498   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35499   bool arg2 ;
35500
35501   arg1 = (Dali::Actor *)jarg1;
35502   arg2 = jarg2 ? true : false;
35503   {
35504     try {
35505       (arg1)->SetInheritScale(arg2);
35506     } catch (std::out_of_range& e) {
35507       {
35508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35509       };
35510     } catch (std::exception& e) {
35511       {
35512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35513       };
35514     } catch (Dali::DaliException e) {
35515       {
35516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35517       };
35518     } catch (...) {
35519       {
35520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35521       };
35522     }
35523   }
35524
35525 }
35526
35527
35528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35529   unsigned int jresult ;
35530   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35531   bool result;
35532
35533   arg1 = (Dali::Actor *)jarg1;
35534   {
35535     try {
35536       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35537     } catch (std::out_of_range& e) {
35538       {
35539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35540       };
35541     } catch (std::exception& e) {
35542       {
35543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35544       };
35545     } catch (Dali::DaliException e) {
35546       {
35547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35548       };
35549     } catch (...) {
35550       {
35551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35552       };
35553     }
35554   }
35555
35556   jresult = result;
35557   return jresult;
35558 }
35559
35560
35561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35562   void * jresult ;
35563   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35564   Dali::Matrix result;
35565
35566   arg1 = (Dali::Actor *)jarg1;
35567   {
35568     try {
35569       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35570     } catch (std::out_of_range& e) {
35571       {
35572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35573       };
35574     } catch (std::exception& e) {
35575       {
35576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35577       };
35578     } catch (Dali::DaliException e) {
35579       {
35580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35581       };
35582     } catch (...) {
35583       {
35584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35585       };
35586     }
35587   }
35588
35589   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35590   return jresult;
35591 }
35592
35593
35594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35595   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35596   bool arg2 ;
35597
35598   arg1 = (Dali::Actor *)jarg1;
35599   arg2 = jarg2 ? true : false;
35600   {
35601     try {
35602       (arg1)->SetVisible(arg2);
35603     } catch (std::out_of_range& e) {
35604       {
35605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35606       };
35607     } catch (std::exception& e) {
35608       {
35609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35610       };
35611     } catch (Dali::DaliException e) {
35612       {
35613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35614       };
35615     } catch (...) {
35616       {
35617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35618       };
35619     }
35620   }
35621
35622 }
35623
35624
35625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35626   unsigned int jresult ;
35627   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35628   bool result;
35629
35630   arg1 = (Dali::Actor *)jarg1;
35631   {
35632     try {
35633       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35634     } catch (std::out_of_range& e) {
35635       {
35636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35637       };
35638     } catch (std::exception& e) {
35639       {
35640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35641       };
35642     } catch (Dali::DaliException e) {
35643       {
35644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35645       };
35646     } catch (...) {
35647       {
35648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35649       };
35650     }
35651   }
35652
35653   jresult = result;
35654   return jresult;
35655 }
35656
35657
35658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35660   float arg2 ;
35661
35662   arg1 = (Dali::Actor *)jarg1;
35663   arg2 = (float)jarg2;
35664   {
35665     try {
35666       (arg1)->SetOpacity(arg2);
35667     } catch (std::out_of_range& e) {
35668       {
35669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35670       };
35671     } catch (std::exception& e) {
35672       {
35673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35674       };
35675     } catch (Dali::DaliException e) {
35676       {
35677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35678       };
35679     } catch (...) {
35680       {
35681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35682       };
35683     }
35684   }
35685
35686 }
35687
35688
35689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35690   float jresult ;
35691   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35692   float result;
35693
35694   arg1 = (Dali::Actor *)jarg1;
35695   {
35696     try {
35697       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35698     } catch (std::out_of_range& e) {
35699       {
35700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35701       };
35702     } catch (std::exception& e) {
35703       {
35704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35705       };
35706     } catch (Dali::DaliException e) {
35707       {
35708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35709       };
35710     } catch (...) {
35711       {
35712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35713       };
35714     }
35715   }
35716
35717   jresult = result;
35718   return jresult;
35719 }
35720
35721
35722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35724   Dali::Vector4 *arg2 = 0 ;
35725
35726   arg1 = (Dali::Actor *)jarg1;
35727   arg2 = (Dali::Vector4 *)jarg2;
35728   if (!arg2) {
35729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35730     return ;
35731   }
35732   {
35733     try {
35734       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35735     } catch (std::out_of_range& e) {
35736       {
35737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35738       };
35739     } catch (std::exception& e) {
35740       {
35741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35742       };
35743     } catch (Dali::DaliException e) {
35744       {
35745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35746       };
35747     } catch (...) {
35748       {
35749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35750       };
35751     }
35752   }
35753
35754 }
35755
35756
35757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35758   void * jresult ;
35759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35760   Dali::Vector4 result;
35761
35762   arg1 = (Dali::Actor *)jarg1;
35763   {
35764     try {
35765       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35766     } catch (std::out_of_range& e) {
35767       {
35768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35769       };
35770     } catch (std::exception& e) {
35771       {
35772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35773       };
35774     } catch (Dali::DaliException e) {
35775       {
35776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35777       };
35778     } catch (...) {
35779       {
35780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35781       };
35782     }
35783   }
35784
35785   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35786   return jresult;
35787 }
35788
35789
35790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35791   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35792   Dali::ColorMode arg2 ;
35793
35794   arg1 = (Dali::Actor *)jarg1;
35795   arg2 = (Dali::ColorMode)jarg2;
35796   {
35797     try {
35798       (arg1)->SetColorMode(arg2);
35799     } catch (std::out_of_range& e) {
35800       {
35801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35802       };
35803     } catch (std::exception& e) {
35804       {
35805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35806       };
35807     } catch (Dali::DaliException e) {
35808       {
35809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35810       };
35811     } catch (...) {
35812       {
35813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35814       };
35815     }
35816   }
35817
35818 }
35819
35820
35821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35822   int jresult ;
35823   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35824   Dali::ColorMode result;
35825
35826   arg1 = (Dali::Actor *)jarg1;
35827   {
35828     try {
35829       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35830     } catch (std::out_of_range& e) {
35831       {
35832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35833       };
35834     } catch (std::exception& e) {
35835       {
35836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35837       };
35838     } catch (Dali::DaliException e) {
35839       {
35840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35841       };
35842     } catch (...) {
35843       {
35844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35845       };
35846     }
35847   }
35848
35849   jresult = (int)result;
35850   return jresult;
35851 }
35852
35853
35854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35855   void * jresult ;
35856   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35857   Dali::Vector4 result;
35858
35859   arg1 = (Dali::Actor *)jarg1;
35860   {
35861     try {
35862       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35863     } catch (std::out_of_range& e) {
35864       {
35865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35866       };
35867     } catch (std::exception& e) {
35868       {
35869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35870       };
35871     } catch (Dali::DaliException e) {
35872       {
35873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35874       };
35875     } catch (...) {
35876       {
35877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35878       };
35879     }
35880   }
35881
35882   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35883   return jresult;
35884 }
35885
35886
35887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35888   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35889   Dali::DrawMode::Type arg2 ;
35890
35891   arg1 = (Dali::Actor *)jarg1;
35892   arg2 = (Dali::DrawMode::Type)jarg2;
35893   {
35894     try {
35895       (arg1)->SetDrawMode(arg2);
35896     } catch (std::out_of_range& e) {
35897       {
35898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35899       };
35900     } catch (std::exception& e) {
35901       {
35902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35903       };
35904     } catch (Dali::DaliException e) {
35905       {
35906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35907       };
35908     } catch (...) {
35909       {
35910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35911       };
35912     }
35913   }
35914
35915 }
35916
35917
35918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35919   int jresult ;
35920   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35921   Dali::DrawMode::Type result;
35922
35923   arg1 = (Dali::Actor *)jarg1;
35924   {
35925     try {
35926       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35927     } catch (std::out_of_range& e) {
35928       {
35929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35930       };
35931     } catch (std::exception& e) {
35932       {
35933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35934       };
35935     } catch (Dali::DaliException e) {
35936       {
35937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35938       };
35939     } catch (...) {
35940       {
35941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35942       };
35943     }
35944   }
35945
35946   jresult = (int)result;
35947   return jresult;
35948 }
35949
35950
35951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35952   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35953   bool arg2 ;
35954
35955   arg1 = (Dali::Actor *)jarg1;
35956   arg2 = jarg2 ? true : false;
35957   {
35958     try {
35959       (arg1)->SetSensitive(arg2);
35960     } catch (std::out_of_range& e) {
35961       {
35962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35963       };
35964     } catch (std::exception& e) {
35965       {
35966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35967       };
35968     } catch (Dali::DaliException e) {
35969       {
35970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35971       };
35972     } catch (...) {
35973       {
35974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35975       };
35976     }
35977   }
35978
35979 }
35980
35981
35982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35983   unsigned int jresult ;
35984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35985   bool result;
35986
35987   arg1 = (Dali::Actor *)jarg1;
35988   {
35989     try {
35990       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35991     } catch (std::out_of_range& e) {
35992       {
35993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35994       };
35995     } catch (std::exception& e) {
35996       {
35997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35998       };
35999     } catch (Dali::DaliException e) {
36000       {
36001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36002       };
36003     } catch (...) {
36004       {
36005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36006       };
36007     }
36008   }
36009
36010   jresult = result;
36011   return jresult;
36012 }
36013
36014
36015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36016   unsigned int jresult ;
36017   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36018   float *arg2 = 0 ;
36019   float *arg3 = 0 ;
36020   float arg4 ;
36021   float arg5 ;
36022   bool result;
36023
36024   arg1 = (Dali::Actor *)jarg1;
36025   arg2 = (float *)jarg2;
36026   arg3 = (float *)jarg3;
36027   arg4 = (float)jarg4;
36028   arg5 = (float)jarg5;
36029   {
36030     try {
36031       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36032     } catch (std::out_of_range& e) {
36033       {
36034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36035       };
36036     } catch (std::exception& e) {
36037       {
36038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36039       };
36040     } catch (Dali::DaliException e) {
36041       {
36042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36043       };
36044     } catch (...) {
36045       {
36046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36047       };
36048     }
36049   }
36050
36051   jresult = result;
36052   return jresult;
36053 }
36054
36055
36056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36057   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36058   bool arg2 ;
36059
36060   arg1 = (Dali::Actor *)jarg1;
36061   arg2 = jarg2 ? true : false;
36062   {
36063     try {
36064       (arg1)->SetLeaveRequired(arg2);
36065     } catch (std::out_of_range& e) {
36066       {
36067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36068       };
36069     } catch (std::exception& e) {
36070       {
36071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36072       };
36073     } catch (Dali::DaliException e) {
36074       {
36075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36076       };
36077     } catch (...) {
36078       {
36079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36080       };
36081     }
36082   }
36083
36084 }
36085
36086
36087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36088   unsigned int jresult ;
36089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36090   bool result;
36091
36092   arg1 = (Dali::Actor *)jarg1;
36093   {
36094     try {
36095       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36096     } catch (std::out_of_range& e) {
36097       {
36098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36099       };
36100     } catch (std::exception& e) {
36101       {
36102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36103       };
36104     } catch (Dali::DaliException e) {
36105       {
36106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36107       };
36108     } catch (...) {
36109       {
36110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36111       };
36112     }
36113   }
36114
36115   jresult = result;
36116   return jresult;
36117 }
36118
36119
36120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36121   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36122   bool arg2 ;
36123
36124   arg1 = (Dali::Actor *)jarg1;
36125   arg2 = jarg2 ? true : false;
36126   {
36127     try {
36128       (arg1)->SetKeyboardFocusable(arg2);
36129     } catch (std::out_of_range& e) {
36130       {
36131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36132       };
36133     } catch (std::exception& e) {
36134       {
36135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36136       };
36137     } catch (Dali::DaliException e) {
36138       {
36139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36140       };
36141     } catch (...) {
36142       {
36143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36144       };
36145     }
36146   }
36147
36148 }
36149
36150
36151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36152   unsigned int jresult ;
36153   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36154   bool result;
36155
36156   arg1 = (Dali::Actor *)jarg1;
36157   {
36158     try {
36159       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36160     } catch (std::out_of_range& e) {
36161       {
36162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36163       };
36164     } catch (std::exception& e) {
36165       {
36166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36167       };
36168     } catch (Dali::DaliException e) {
36169       {
36170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36171       };
36172     } catch (...) {
36173       {
36174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36175       };
36176     }
36177   }
36178
36179   jresult = result;
36180   return jresult;
36181 }
36182
36183
36184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36186   Dali::ResizePolicy::Type arg2 ;
36187   Dali::Dimension::Type arg3 ;
36188
36189   arg1 = (Dali::Actor *)jarg1;
36190   arg2 = (Dali::ResizePolicy::Type)jarg2;
36191   arg3 = (Dali::Dimension::Type)jarg3;
36192   {
36193     try {
36194       (arg1)->SetResizePolicy(arg2,arg3);
36195     } catch (std::out_of_range& e) {
36196       {
36197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36198       };
36199     } catch (std::exception& e) {
36200       {
36201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36202       };
36203     } catch (Dali::DaliException e) {
36204       {
36205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36206       };
36207     } catch (...) {
36208       {
36209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36210       };
36211     }
36212   }
36213
36214 }
36215
36216
36217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36218   int jresult ;
36219   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36220   Dali::Dimension::Type arg2 ;
36221   Dali::ResizePolicy::Type result;
36222
36223   arg1 = (Dali::Actor *)jarg1;
36224   arg2 = (Dali::Dimension::Type)jarg2;
36225   {
36226     try {
36227       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36228     } catch (std::out_of_range& e) {
36229       {
36230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36231       };
36232     } catch (std::exception& e) {
36233       {
36234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36235       };
36236     } catch (Dali::DaliException e) {
36237       {
36238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36239       };
36240     } catch (...) {
36241       {
36242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36243       };
36244     }
36245   }
36246
36247   jresult = (int)result;
36248   return jresult;
36249 }
36250
36251
36252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36254   Dali::SizeScalePolicy::Type arg2 ;
36255
36256   arg1 = (Dali::Actor *)jarg1;
36257   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36258   {
36259     try {
36260       (arg1)->SetSizeScalePolicy(arg2);
36261     } catch (std::out_of_range& e) {
36262       {
36263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36264       };
36265     } catch (std::exception& e) {
36266       {
36267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36268       };
36269     } catch (Dali::DaliException e) {
36270       {
36271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36272       };
36273     } catch (...) {
36274       {
36275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36276       };
36277     }
36278   }
36279
36280 }
36281
36282
36283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36284   int jresult ;
36285   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36286   Dali::SizeScalePolicy::Type result;
36287
36288   arg1 = (Dali::Actor *)jarg1;
36289   {
36290     try {
36291       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36292     } catch (std::out_of_range& e) {
36293       {
36294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36295       };
36296     } catch (std::exception& e) {
36297       {
36298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36299       };
36300     } catch (Dali::DaliException e) {
36301       {
36302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36303       };
36304     } catch (...) {
36305       {
36306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36307       };
36308     }
36309   }
36310
36311   jresult = (int)result;
36312   return jresult;
36313 }
36314
36315
36316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36317   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36318   Dali::Vector3 *arg2 = 0 ;
36319
36320   arg1 = (Dali::Actor *)jarg1;
36321   arg2 = (Dali::Vector3 *)jarg2;
36322   if (!arg2) {
36323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36324     return ;
36325   }
36326   {
36327     try {
36328       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36329     } catch (std::out_of_range& e) {
36330       {
36331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36332       };
36333     } catch (std::exception& e) {
36334       {
36335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36336       };
36337     } catch (Dali::DaliException e) {
36338       {
36339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36340       };
36341     } catch (...) {
36342       {
36343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36344       };
36345     }
36346   }
36347
36348 }
36349
36350
36351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36352   void * jresult ;
36353   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36354   Dali::Vector3 result;
36355
36356   arg1 = (Dali::Actor *)jarg1;
36357   {
36358     try {
36359       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36360     } catch (std::out_of_range& e) {
36361       {
36362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36363       };
36364     } catch (std::exception& e) {
36365       {
36366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36367       };
36368     } catch (Dali::DaliException e) {
36369       {
36370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36371       };
36372     } catch (...) {
36373       {
36374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36375       };
36376     }
36377   }
36378
36379   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36380   return jresult;
36381 }
36382
36383
36384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36385   float jresult ;
36386   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36387   float arg2 ;
36388   float result;
36389
36390   arg1 = (Dali::Actor *)jarg1;
36391   arg2 = (float)jarg2;
36392   {
36393     try {
36394       result = (float)(arg1)->GetHeightForWidth(arg2);
36395     } catch (std::out_of_range& e) {
36396       {
36397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36398       };
36399     } catch (std::exception& e) {
36400       {
36401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36402       };
36403     } catch (Dali::DaliException e) {
36404       {
36405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36406       };
36407     } catch (...) {
36408       {
36409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36410       };
36411     }
36412   }
36413
36414   jresult = result;
36415   return jresult;
36416 }
36417
36418
36419 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36420   float jresult ;
36421   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36422   float arg2 ;
36423   float result;
36424
36425   arg1 = (Dali::Actor *)jarg1;
36426   arg2 = (float)jarg2;
36427   {
36428     try {
36429       result = (float)(arg1)->GetWidthForHeight(arg2);
36430     } catch (std::out_of_range& e) {
36431       {
36432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36433       };
36434     } catch (std::exception& e) {
36435       {
36436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36437       };
36438     } catch (Dali::DaliException e) {
36439       {
36440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36441       };
36442     } catch (...) {
36443       {
36444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36445       };
36446     }
36447   }
36448
36449   jresult = result;
36450   return jresult;
36451 }
36452
36453
36454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36455   float jresult ;
36456   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36457   Dali::Dimension::Type arg2 ;
36458   float result;
36459
36460   arg1 = (Dali::Actor *)jarg1;
36461   arg2 = (Dali::Dimension::Type)jarg2;
36462   {
36463     try {
36464       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36465     } catch (std::out_of_range& e) {
36466       {
36467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36468       };
36469     } catch (std::exception& e) {
36470       {
36471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36472       };
36473     } catch (Dali::DaliException e) {
36474       {
36475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36476       };
36477     } catch (...) {
36478       {
36479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36480       };
36481     }
36482   }
36483
36484   jresult = result;
36485   return jresult;
36486 }
36487
36488
36489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36491   Dali::Padding *arg2 = 0 ;
36492
36493   arg1 = (Dali::Actor *)jarg1;
36494   arg2 = (Dali::Padding *)jarg2;
36495   if (!arg2) {
36496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36497     return ;
36498   }
36499   {
36500     try {
36501       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36502     } catch (std::out_of_range& e) {
36503       {
36504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36505       };
36506     } catch (std::exception& e) {
36507       {
36508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36509       };
36510     } catch (Dali::DaliException e) {
36511       {
36512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36513       };
36514     } catch (...) {
36515       {
36516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36517       };
36518     }
36519   }
36520
36521 }
36522
36523
36524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36525   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36526   Dali::Padding *arg2 = 0 ;
36527
36528   arg1 = (Dali::Actor *)jarg1;
36529   arg2 = (Dali::Padding *)jarg2;
36530   if (!arg2) {
36531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36532     return ;
36533   }
36534   {
36535     try {
36536       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36537     } catch (std::out_of_range& e) {
36538       {
36539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36540       };
36541     } catch (std::exception& e) {
36542       {
36543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36544       };
36545     } catch (Dali::DaliException e) {
36546       {
36547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36548       };
36549     } catch (...) {
36550       {
36551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36552       };
36553     }
36554   }
36555
36556 }
36557
36558
36559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36560   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36561   Dali::Vector2 *arg2 = 0 ;
36562
36563   arg1 = (Dali::Actor *)jarg1;
36564   arg2 = (Dali::Vector2 *)jarg2;
36565   if (!arg2) {
36566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36567     return ;
36568   }
36569   {
36570     try {
36571       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36572     } catch (std::out_of_range& e) {
36573       {
36574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36575       };
36576     } catch (std::exception& e) {
36577       {
36578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36579       };
36580     } catch (Dali::DaliException e) {
36581       {
36582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36583       };
36584     } catch (...) {
36585       {
36586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36587       };
36588     }
36589   }
36590
36591 }
36592
36593
36594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36595   void * jresult ;
36596   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36597   Dali::Vector2 result;
36598
36599   arg1 = (Dali::Actor *)jarg1;
36600   {
36601     try {
36602       result = (arg1)->GetMinimumSize();
36603     } catch (std::out_of_range& e) {
36604       {
36605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36606       };
36607     } catch (std::exception& e) {
36608       {
36609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36610       };
36611     } catch (Dali::DaliException e) {
36612       {
36613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36614       };
36615     } catch (...) {
36616       {
36617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36618       };
36619     }
36620   }
36621
36622   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36623   return jresult;
36624 }
36625
36626
36627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36628   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36629   Dali::Vector2 *arg2 = 0 ;
36630
36631   arg1 = (Dali::Actor *)jarg1;
36632   arg2 = (Dali::Vector2 *)jarg2;
36633   if (!arg2) {
36634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36635     return ;
36636   }
36637   {
36638     try {
36639       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36640     } catch (std::out_of_range& e) {
36641       {
36642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36643       };
36644     } catch (std::exception& e) {
36645       {
36646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36647       };
36648     } catch (Dali::DaliException e) {
36649       {
36650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36651       };
36652     } catch (...) {
36653       {
36654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36655       };
36656     }
36657   }
36658
36659 }
36660
36661
36662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36663   void * jresult ;
36664   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36665   Dali::Vector2 result;
36666
36667   arg1 = (Dali::Actor *)jarg1;
36668   {
36669     try {
36670       result = (arg1)->GetMaximumSize();
36671     } catch (std::out_of_range& e) {
36672       {
36673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36674       };
36675     } catch (std::exception& e) {
36676       {
36677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36678       };
36679     } catch (Dali::DaliException e) {
36680       {
36681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36682       };
36683     } catch (...) {
36684       {
36685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36686       };
36687     }
36688   }
36689
36690   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36691   return jresult;
36692 }
36693
36694
36695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36696   int jresult ;
36697   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36698   int result;
36699
36700   arg1 = (Dali::Actor *)jarg1;
36701   {
36702     try {
36703       result = (int)(arg1)->GetHierarchyDepth();
36704       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36705       if(parent)
36706       {
36707         const std::string parentName = parent.GetName();
36708         if(parentName.compare("rootAbsoluteLayout") == 0)
36709         {
36710           result -= 1;
36711         }
36712       }
36713     } catch (std::out_of_range& e) {
36714       {
36715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36716       };
36717     } catch (std::exception& e) {
36718       {
36719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36720       };
36721     } catch (Dali::DaliException e) {
36722       {
36723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36724       };
36725     } catch (...) {
36726       {
36727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36728       };
36729     }
36730   }
36731
36732   jresult = result;
36733   return jresult;
36734 }
36735
36736
36737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36738   unsigned int jresult ;
36739   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36740   Dali::Renderer *arg2 = 0 ;
36741   unsigned int result;
36742
36743   arg1 = (Dali::Actor *)jarg1;
36744   arg2 = (Dali::Renderer *)jarg2;
36745   if (!arg2) {
36746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36747     return 0;
36748   }
36749   {
36750     try {
36751       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36752     } catch (std::out_of_range& e) {
36753       {
36754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36755       };
36756     } catch (std::exception& e) {
36757       {
36758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36759       };
36760     } catch (Dali::DaliException e) {
36761       {
36762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36763       };
36764     } catch (...) {
36765       {
36766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36767       };
36768     }
36769   }
36770
36771   jresult = result;
36772   return jresult;
36773 }
36774
36775
36776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36777   unsigned int jresult ;
36778   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36779   unsigned int result;
36780
36781   arg1 = (Dali::Actor *)jarg1;
36782   {
36783     try {
36784       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36785     } catch (std::out_of_range& e) {
36786       {
36787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36788       };
36789     } catch (std::exception& e) {
36790       {
36791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36792       };
36793     } catch (Dali::DaliException e) {
36794       {
36795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36796       };
36797     } catch (...) {
36798       {
36799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36800       };
36801     }
36802   }
36803
36804   jresult = result;
36805   return jresult;
36806 }
36807
36808
36809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36810   void * jresult ;
36811   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36812   unsigned int arg2 ;
36813   Dali::Renderer result;
36814
36815   arg1 = (Dali::Actor *)jarg1;
36816   arg2 = (unsigned int)jarg2;
36817   {
36818     try {
36819       result = (arg1)->GetRendererAt(arg2);
36820     } catch (std::out_of_range& e) {
36821       {
36822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36823       };
36824     } catch (std::exception& e) {
36825       {
36826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36827       };
36828     } catch (Dali::DaliException e) {
36829       {
36830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36831       };
36832     } catch (...) {
36833       {
36834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36835       };
36836     }
36837   }
36838
36839   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36840   return jresult;
36841 }
36842
36843
36844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36845   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36846   Dali::Renderer *arg2 = 0 ;
36847
36848   arg1 = (Dali::Actor *)jarg1;
36849   arg2 = (Dali::Renderer *)jarg2;
36850   if (!arg2) {
36851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36852     return ;
36853   }
36854   {
36855     try {
36856       (arg1)->RemoveRenderer(*arg2);
36857     } catch (std::out_of_range& e) {
36858       {
36859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36860       };
36861     } catch (std::exception& e) {
36862       {
36863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36864       };
36865     } catch (Dali::DaliException e) {
36866       {
36867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36868       };
36869     } catch (...) {
36870       {
36871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36872       };
36873     }
36874   }
36875
36876 }
36877
36878
36879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36880   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36881   unsigned int arg2 ;
36882
36883   arg1 = (Dali::Actor *)jarg1;
36884   arg2 = (unsigned int)jarg2;
36885   {
36886     try {
36887       (arg1)->RemoveRenderer(arg2);
36888     } catch (std::out_of_range& e) {
36889       {
36890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36891       };
36892     } catch (std::exception& e) {
36893       {
36894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36895       };
36896     } catch (Dali::DaliException e) {
36897       {
36898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36899       };
36900     } catch (...) {
36901       {
36902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36903       };
36904     }
36905   }
36906
36907 }
36908
36909
36910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36911   void * jresult ;
36912   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36913   Dali::Actor::TouchSignalType *result = 0 ;
36914
36915   arg1 = (Dali::Actor *)jarg1;
36916   {
36917     try {
36918       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36919     } catch (std::out_of_range& e) {
36920       {
36921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36922       };
36923     } catch (std::exception& e) {
36924       {
36925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36926       };
36927     } catch (Dali::DaliException e) {
36928       {
36929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36930       };
36931     } catch (...) {
36932       {
36933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36934       };
36935     }
36936   }
36937
36938   jresult = (void *)result;
36939   return jresult;
36940 }
36941
36942
36943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36944   void * jresult ;
36945   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36946   Dali::Actor::TouchDataSignalType *result = 0 ;
36947
36948   arg1 = (Dali::Actor *)jarg1;
36949   {
36950     try {
36951       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36952     } catch (std::out_of_range& e) {
36953       {
36954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36955       };
36956     } catch (std::exception& e) {
36957       {
36958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36959       };
36960     } catch (Dali::DaliException e) {
36961       {
36962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36963       };
36964     } catch (...) {
36965       {
36966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36967       };
36968     }
36969   }
36970
36971   jresult = (void *)result;
36972   return jresult;
36973 }
36974
36975
36976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36977   void * jresult ;
36978   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36979   Dali::Actor::HoverSignalType *result = 0 ;
36980
36981   arg1 = (Dali::Actor *)jarg1;
36982   {
36983     try {
36984       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36985     } catch (std::out_of_range& e) {
36986       {
36987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36988       };
36989     } catch (std::exception& e) {
36990       {
36991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36992       };
36993     } catch (Dali::DaliException e) {
36994       {
36995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36996       };
36997     } catch (...) {
36998       {
36999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37000       };
37001     }
37002   }
37003
37004   jresult = (void *)result;
37005   return jresult;
37006 }
37007
37008
37009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37010   void * jresult ;
37011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37012   Dali::Actor::WheelEventSignalType *result = 0 ;
37013
37014   arg1 = (Dali::Actor *)jarg1;
37015   {
37016     try {
37017       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37018     } catch (std::out_of_range& e) {
37019       {
37020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37021       };
37022     } catch (std::exception& e) {
37023       {
37024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37025       };
37026     } catch (Dali::DaliException e) {
37027       {
37028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37029       };
37030     } catch (...) {
37031       {
37032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37033       };
37034     }
37035   }
37036
37037   jresult = (void *)result;
37038   return jresult;
37039 }
37040
37041
37042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37043   void * jresult ;
37044   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37045   Dali::Actor::OnStageSignalType *result = 0 ;
37046
37047   arg1 = (Dali::Actor *)jarg1;
37048   {
37049     try {
37050       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37051     } catch (std::out_of_range& e) {
37052       {
37053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37054       };
37055     } catch (std::exception& e) {
37056       {
37057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37058       };
37059     } catch (Dali::DaliException e) {
37060       {
37061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37062       };
37063     } catch (...) {
37064       {
37065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37066       };
37067     }
37068   }
37069
37070   jresult = (void *)result;
37071   return jresult;
37072 }
37073
37074
37075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37076   void * jresult ;
37077   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37078   Dali::Actor::OffStageSignalType *result = 0 ;
37079
37080   arg1 = (Dali::Actor *)jarg1;
37081   {
37082     try {
37083       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37084     } catch (std::out_of_range& e) {
37085       {
37086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37087       };
37088     } catch (std::exception& e) {
37089       {
37090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37091       };
37092     } catch (Dali::DaliException e) {
37093       {
37094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37095       };
37096     } catch (...) {
37097       {
37098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37099       };
37100     }
37101   }
37102
37103   jresult = (void *)result;
37104   return jresult;
37105 }
37106
37107
37108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37109   void * jresult ;
37110   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37111   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37112
37113   arg1 = (Dali::Actor *)jarg1;
37114   {
37115     try {
37116       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37117     } catch (std::out_of_range& e) {
37118       {
37119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37120       };
37121     } catch (std::exception& e) {
37122       {
37123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37124       };
37125     } catch (Dali::DaliException e) {
37126       {
37127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37128       };
37129     } catch (...) {
37130       {
37131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37132       };
37133     }
37134   }
37135
37136   jresult = (void *)result;
37137   return jresult;
37138 }
37139
37140
37141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37142   Dali::Actor *arg1 = 0 ;
37143
37144   arg1 = (Dali::Actor *)jarg1;
37145   if (!arg1) {
37146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37147     return ;
37148   }
37149   {
37150     try {
37151       Dali::UnparentAndReset(*arg1);
37152     } catch (std::out_of_range& e) {
37153       {
37154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37155       };
37156     } catch (std::exception& e) {
37157       {
37158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37159       };
37160     } catch (Dali::DaliException e) {
37161       {
37162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37163       };
37164     } catch (...) {
37165       {
37166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37167       };
37168     }
37169   }
37170
37171 }
37172
37173
37174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37175   int jresult ;
37176   int result;
37177
37178   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37179   jresult = (int)result;
37180   return jresult;
37181 }
37182
37183
37184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37185   int jresult ;
37186   int result;
37187
37188   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37189   jresult = (int)result;
37190   return jresult;
37191 }
37192
37193
37194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37195   int jresult ;
37196   int result;
37197
37198   result = (int)Dali::Layer::Property::BEHAVIOR;
37199   jresult = (int)result;
37200   return jresult;
37201 }
37202
37203
37204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37205   void * jresult ;
37206   Dali::Layer::Property *result = 0 ;
37207
37208   {
37209     try {
37210       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37211     } catch (std::out_of_range& e) {
37212       {
37213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37214       };
37215     } catch (std::exception& e) {
37216       {
37217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37218       };
37219     } catch (Dali::DaliException e) {
37220       {
37221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37222       };
37223     } catch (...) {
37224       {
37225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37226       };
37227     }
37228   }
37229
37230   jresult = (void *)result;
37231   return jresult;
37232 }
37233
37234
37235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37236   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37237
37238   arg1 = (Dali::Layer::Property *)jarg1;
37239   {
37240     try {
37241       delete arg1;
37242     } catch (std::out_of_range& e) {
37243       {
37244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37245       };
37246     } catch (std::exception& e) {
37247       {
37248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37249       };
37250     } catch (Dali::DaliException e) {
37251       {
37252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37253       };
37254     } catch (...) {
37255       {
37256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37257       };
37258     }
37259   }
37260
37261 }
37262
37263
37264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37265   void * jresult ;
37266   Dali::Layer *result = 0 ;
37267
37268   {
37269     try {
37270       result = (Dali::Layer *)new Dali::Layer();
37271     } catch (std::out_of_range& e) {
37272       {
37273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37274       };
37275     } catch (std::exception& e) {
37276       {
37277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37278       };
37279     } catch (Dali::DaliException e) {
37280       {
37281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37282       };
37283     } catch (...) {
37284       {
37285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37286       };
37287     }
37288   }
37289
37290   jresult = (void *)result;
37291   return jresult;
37292 }
37293
37294
37295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37296   void * jresult ;
37297   Dali::Layer result;
37298
37299   {
37300     try {
37301       result = Dali::Layer::New();
37302     } catch (std::out_of_range& e) {
37303       {
37304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37305       };
37306     } catch (std::exception& e) {
37307       {
37308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37309       };
37310     } catch (Dali::DaliException e) {
37311       {
37312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37313       };
37314     } catch (...) {
37315       {
37316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37317       };
37318     }
37319   }
37320
37321   jresult = new Dali::Layer((const Dali::Layer &)result);
37322   return jresult;
37323 }
37324
37325
37326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37327   void * jresult ;
37328   Dali::BaseHandle arg1 ;
37329   Dali::BaseHandle *argp1 ;
37330   Dali::Layer result;
37331
37332   argp1 = (Dali::BaseHandle *)jarg1;
37333   if (!argp1) {
37334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37335     return 0;
37336   }
37337   arg1 = *argp1;
37338   {
37339     try {
37340       result = Dali::Layer::DownCast(arg1);
37341     } catch (std::out_of_range& e) {
37342       {
37343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37344       };
37345     } catch (std::exception& e) {
37346       {
37347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37348       };
37349     } catch (Dali::DaliException e) {
37350       {
37351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37352       };
37353     } catch (...) {
37354       {
37355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37356       };
37357     }
37358   }
37359
37360   jresult = new Dali::Layer((const Dali::Layer &)result);
37361   return jresult;
37362 }
37363
37364
37365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37366   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37367
37368   arg1 = (Dali::Layer *)jarg1;
37369   {
37370     try {
37371       delete arg1;
37372     } catch (std::out_of_range& e) {
37373       {
37374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37375       };
37376     } catch (std::exception& e) {
37377       {
37378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37379       };
37380     } catch (Dali::DaliException e) {
37381       {
37382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37383       };
37384     } catch (...) {
37385       {
37386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37387       };
37388     }
37389   }
37390
37391 }
37392
37393
37394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37395   void * jresult ;
37396   Dali::Layer *arg1 = 0 ;
37397   Dali::Layer *result = 0 ;
37398
37399   arg1 = (Dali::Layer *)jarg1;
37400   if (!arg1) {
37401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37402     return 0;
37403   }
37404   {
37405     try {
37406       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37407     } catch (std::out_of_range& e) {
37408       {
37409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37410       };
37411     } catch (std::exception& e) {
37412       {
37413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37414       };
37415     } catch (Dali::DaliException e) {
37416       {
37417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37418       };
37419     } catch (...) {
37420       {
37421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37422       };
37423     }
37424   }
37425
37426   jresult = (void *)result;
37427   return jresult;
37428 }
37429
37430
37431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37432   void * jresult ;
37433   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37434   Dali::Layer *arg2 = 0 ;
37435   Dali::Layer *result = 0 ;
37436
37437   arg1 = (Dali::Layer *)jarg1;
37438   arg2 = (Dali::Layer *)jarg2;
37439   if (!arg2) {
37440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37441     return 0;
37442   }
37443   {
37444     try {
37445       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37446     } catch (std::out_of_range& e) {
37447       {
37448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37449       };
37450     } catch (std::exception& e) {
37451       {
37452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37453       };
37454     } catch (Dali::DaliException e) {
37455       {
37456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37457       };
37458     } catch (...) {
37459       {
37460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37461       };
37462     }
37463   }
37464
37465   jresult = (void *)result;
37466   return jresult;
37467 }
37468
37469
37470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37471   unsigned int jresult ;
37472   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37473   unsigned int result;
37474
37475   arg1 = (Dali::Layer *)jarg1;
37476   {
37477     try {
37478       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37479     } catch (std::out_of_range& e) {
37480       {
37481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37482       };
37483     } catch (std::exception& e) {
37484       {
37485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37486       };
37487     } catch (Dali::DaliException e) {
37488       {
37489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37490       };
37491     } catch (...) {
37492       {
37493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37494       };
37495     }
37496   }
37497
37498   jresult = result;
37499   return jresult;
37500 }
37501
37502
37503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37504   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37505
37506   arg1 = (Dali::Layer *)jarg1;
37507   {
37508     try {
37509       (arg1)->Raise();
37510     } catch (std::out_of_range& e) {
37511       {
37512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37513       };
37514     } catch (std::exception& e) {
37515       {
37516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37517       };
37518     } catch (Dali::DaliException e) {
37519       {
37520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37521       };
37522     } catch (...) {
37523       {
37524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37525       };
37526     }
37527   }
37528
37529 }
37530
37531
37532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37533   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37534
37535   arg1 = (Dali::Layer *)jarg1;
37536   {
37537     try {
37538       (arg1)->Lower();
37539     } catch (std::out_of_range& e) {
37540       {
37541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37542       };
37543     } catch (std::exception& e) {
37544       {
37545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37546       };
37547     } catch (Dali::DaliException e) {
37548       {
37549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37550       };
37551     } catch (...) {
37552       {
37553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37554       };
37555     }
37556   }
37557
37558 }
37559
37560
37561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37562   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37563   Dali::Layer arg2 ;
37564   Dali::Layer *argp2 ;
37565
37566   arg1 = (Dali::Layer *)jarg1;
37567   argp2 = (Dali::Layer *)jarg2;
37568   if (!argp2) {
37569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37570     return ;
37571   }
37572   arg2 = *argp2;
37573   {
37574     try {
37575       (arg1)->RaiseAbove(arg2);
37576     } catch (std::out_of_range& e) {
37577       {
37578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37579       };
37580     } catch (std::exception& e) {
37581       {
37582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37583       };
37584     } catch (Dali::DaliException e) {
37585       {
37586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37587       };
37588     } catch (...) {
37589       {
37590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37591       };
37592     }
37593   }
37594
37595 }
37596
37597
37598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37599   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37600   Dali::Layer arg2 ;
37601   Dali::Layer *argp2 ;
37602
37603   arg1 = (Dali::Layer *)jarg1;
37604   argp2 = (Dali::Layer *)jarg2;
37605   if (!argp2) {
37606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37607     return ;
37608   }
37609   arg2 = *argp2;
37610   {
37611     try {
37612       (arg1)->LowerBelow(arg2);
37613     } catch (std::out_of_range& e) {
37614       {
37615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37616       };
37617     } catch (std::exception& e) {
37618       {
37619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37620       };
37621     } catch (Dali::DaliException e) {
37622       {
37623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37624       };
37625     } catch (...) {
37626       {
37627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37628       };
37629     }
37630   }
37631
37632 }
37633
37634
37635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37636   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37637
37638   arg1 = (Dali::Layer *)jarg1;
37639   {
37640     try {
37641       (arg1)->RaiseToTop();
37642     } catch (std::out_of_range& e) {
37643       {
37644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37645       };
37646     } catch (std::exception& e) {
37647       {
37648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37649       };
37650     } catch (Dali::DaliException e) {
37651       {
37652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37653       };
37654     } catch (...) {
37655       {
37656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37657       };
37658     }
37659   }
37660
37661 }
37662
37663
37664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37665   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37666
37667   arg1 = (Dali::Layer *)jarg1;
37668   {
37669     try {
37670       (arg1)->LowerToBottom();
37671     } catch (std::out_of_range& e) {
37672       {
37673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37674       };
37675     } catch (std::exception& e) {
37676       {
37677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37678       };
37679     } catch (Dali::DaliException e) {
37680       {
37681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37682       };
37683     } catch (...) {
37684       {
37685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37686       };
37687     }
37688   }
37689
37690 }
37691
37692
37693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37694   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37695   Dali::Layer arg2 ;
37696   Dali::Layer *argp2 ;
37697
37698   arg1 = (Dali::Layer *)jarg1;
37699   argp2 = (Dali::Layer *)jarg2;
37700   if (!argp2) {
37701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37702     return ;
37703   }
37704   arg2 = *argp2;
37705   {
37706     try {
37707       (arg1)->MoveAbove(arg2);
37708     } catch (std::out_of_range& e) {
37709       {
37710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37711       };
37712     } catch (std::exception& e) {
37713       {
37714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37715       };
37716     } catch (Dali::DaliException e) {
37717       {
37718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37719       };
37720     } catch (...) {
37721       {
37722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37723       };
37724     }
37725   }
37726
37727 }
37728
37729
37730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37731   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37732   Dali::Layer arg2 ;
37733   Dali::Layer *argp2 ;
37734
37735   arg1 = (Dali::Layer *)jarg1;
37736   argp2 = (Dali::Layer *)jarg2;
37737   if (!argp2) {
37738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37739     return ;
37740   }
37741   arg2 = *argp2;
37742   {
37743     try {
37744       (arg1)->MoveBelow(arg2);
37745     } catch (std::out_of_range& e) {
37746       {
37747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37748       };
37749     } catch (std::exception& e) {
37750       {
37751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37752       };
37753     } catch (Dali::DaliException e) {
37754       {
37755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37756       };
37757     } catch (...) {
37758       {
37759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37760       };
37761     }
37762   }
37763
37764 }
37765
37766
37767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37768   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37769   Dali::Layer::Behavior arg2 ;
37770
37771   arg1 = (Dali::Layer *)jarg1;
37772   arg2 = (Dali::Layer::Behavior)jarg2;
37773   {
37774     try {
37775       (arg1)->SetBehavior(arg2);
37776     } catch (std::out_of_range& e) {
37777       {
37778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37779       };
37780     } catch (std::exception& e) {
37781       {
37782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37783       };
37784     } catch (Dali::DaliException e) {
37785       {
37786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37787       };
37788     } catch (...) {
37789       {
37790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37791       };
37792     }
37793   }
37794
37795 }
37796
37797
37798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37799   int jresult ;
37800   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37801   Dali::Layer::Behavior result;
37802
37803   arg1 = (Dali::Layer *)jarg1;
37804   {
37805     try {
37806       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37807     } catch (std::out_of_range& e) {
37808       {
37809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37810       };
37811     } catch (std::exception& e) {
37812       {
37813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37814       };
37815     } catch (Dali::DaliException e) {
37816       {
37817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37818       };
37819     } catch (...) {
37820       {
37821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37822       };
37823     }
37824   }
37825
37826   jresult = (int)result;
37827   return jresult;
37828 }
37829
37830
37831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37832   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37833   bool arg2 ;
37834
37835   arg1 = (Dali::Layer *)jarg1;
37836   arg2 = jarg2 ? true : false;
37837   {
37838     try {
37839       (arg1)->SetClipping(arg2);
37840     } catch (std::out_of_range& e) {
37841       {
37842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37843       };
37844     } catch (std::exception& e) {
37845       {
37846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37847       };
37848     } catch (Dali::DaliException e) {
37849       {
37850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37851       };
37852     } catch (...) {
37853       {
37854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37855       };
37856     }
37857   }
37858
37859 }
37860
37861
37862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37863   unsigned int jresult ;
37864   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37865   bool result;
37866
37867   arg1 = (Dali::Layer *)jarg1;
37868   {
37869     try {
37870       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37871     } catch (std::out_of_range& e) {
37872       {
37873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37874       };
37875     } catch (std::exception& e) {
37876       {
37877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37878       };
37879     } catch (Dali::DaliException e) {
37880       {
37881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37882       };
37883     } catch (...) {
37884       {
37885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37886       };
37887     }
37888   }
37889
37890   jresult = result;
37891   return jresult;
37892 }
37893
37894
37895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37896   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37897   int arg2 ;
37898   int arg3 ;
37899   int arg4 ;
37900   int arg5 ;
37901
37902   arg1 = (Dali::Layer *)jarg1;
37903   arg2 = (int)jarg2;
37904   arg3 = (int)jarg3;
37905   arg4 = (int)jarg4;
37906   arg5 = (int)jarg5;
37907   {
37908     try {
37909       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37910     } catch (std::out_of_range& e) {
37911       {
37912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37913       };
37914     } catch (std::exception& e) {
37915       {
37916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37917       };
37918     } catch (Dali::DaliException e) {
37919       {
37920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37921       };
37922     } catch (...) {
37923       {
37924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37925       };
37926     }
37927   }
37928
37929 }
37930
37931
37932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37933   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37934   Dali::ClippingBox arg2 ;
37935   Dali::ClippingBox *argp2 ;
37936
37937   arg1 = (Dali::Layer *)jarg1;
37938   argp2 = (Dali::ClippingBox *)jarg2;
37939   if (!argp2) {
37940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37941     return ;
37942   }
37943   arg2 = *argp2;
37944   {
37945     try {
37946       (arg1)->SetClippingBox(arg2);
37947     } catch (std::out_of_range& e) {
37948       {
37949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37950       };
37951     } catch (std::exception& e) {
37952       {
37953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37954       };
37955     } catch (Dali::DaliException e) {
37956       {
37957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37958       };
37959     } catch (...) {
37960       {
37961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37962       };
37963     }
37964   }
37965
37966 }
37967
37968
37969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37970   void * jresult ;
37971   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37972   Dali::ClippingBox result;
37973
37974   arg1 = (Dali::Layer *)jarg1;
37975   {
37976     try {
37977       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37978     } catch (std::out_of_range& e) {
37979       {
37980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37981       };
37982     } catch (std::exception& e) {
37983       {
37984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37985       };
37986     } catch (Dali::DaliException e) {
37987       {
37988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37989       };
37990     } catch (...) {
37991       {
37992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37993       };
37994     }
37995   }
37996
37997   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37998   return jresult;
37999 }
38000
38001
38002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38003   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38004   bool arg2 ;
38005
38006   arg1 = (Dali::Layer *)jarg1;
38007   arg2 = jarg2 ? true : false;
38008   {
38009     try {
38010       (arg1)->SetDepthTestDisabled(arg2);
38011     } catch (std::out_of_range& e) {
38012       {
38013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38014       };
38015     } catch (std::exception& e) {
38016       {
38017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38018       };
38019     } catch (Dali::DaliException e) {
38020       {
38021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38022       };
38023     } catch (...) {
38024       {
38025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38026       };
38027     }
38028   }
38029
38030 }
38031
38032
38033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38034   unsigned int jresult ;
38035   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38036   bool result;
38037
38038   arg1 = (Dali::Layer *)jarg1;
38039   {
38040     try {
38041       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38042     } catch (std::out_of_range& e) {
38043       {
38044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38045       };
38046     } catch (std::exception& e) {
38047       {
38048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38049       };
38050     } catch (Dali::DaliException e) {
38051       {
38052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38053       };
38054     } catch (...) {
38055       {
38056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38057       };
38058     }
38059   }
38060
38061   jresult = result;
38062   return jresult;
38063 }
38064
38065
38066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38067   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38068   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38069
38070   arg1 = (Dali::Layer *)jarg1;
38071   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38072   {
38073     try {
38074       (arg1)->SetSortFunction(arg2);
38075     } catch (std::out_of_range& e) {
38076       {
38077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38078       };
38079     } catch (std::exception& e) {
38080       {
38081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38082       };
38083     } catch (Dali::DaliException e) {
38084       {
38085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38086       };
38087     } catch (...) {
38088       {
38089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38090       };
38091     }
38092   }
38093
38094 }
38095
38096
38097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38098   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38099   bool arg2 ;
38100
38101   arg1 = (Dali::Layer *)jarg1;
38102   arg2 = jarg2 ? true : false;
38103   {
38104     try {
38105       (arg1)->SetTouchConsumed(arg2);
38106     } catch (std::out_of_range& e) {
38107       {
38108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38109       };
38110     } catch (std::exception& e) {
38111       {
38112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38113       };
38114     } catch (Dali::DaliException e) {
38115       {
38116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38117       };
38118     } catch (...) {
38119       {
38120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38121       };
38122     }
38123   }
38124
38125 }
38126
38127
38128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38129   unsigned int jresult ;
38130   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38131   bool result;
38132
38133   arg1 = (Dali::Layer *)jarg1;
38134   {
38135     try {
38136       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38137     } catch (std::out_of_range& e) {
38138       {
38139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38140       };
38141     } catch (std::exception& e) {
38142       {
38143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38144       };
38145     } catch (Dali::DaliException e) {
38146       {
38147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38148       };
38149     } catch (...) {
38150       {
38151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38152       };
38153     }
38154   }
38155
38156   jresult = result;
38157   return jresult;
38158 }
38159
38160
38161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38162   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38163   bool arg2 ;
38164
38165   arg1 = (Dali::Layer *)jarg1;
38166   arg2 = jarg2 ? true : false;
38167   {
38168     try {
38169       (arg1)->SetHoverConsumed(arg2);
38170     } catch (std::out_of_range& e) {
38171       {
38172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38173       };
38174     } catch (std::exception& e) {
38175       {
38176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38177       };
38178     } catch (Dali::DaliException e) {
38179       {
38180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38181       };
38182     } catch (...) {
38183       {
38184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38185       };
38186     }
38187   }
38188
38189 }
38190
38191
38192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38193   unsigned int jresult ;
38194   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38195   bool result;
38196
38197   arg1 = (Dali::Layer *)jarg1;
38198   {
38199     try {
38200       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38201     } catch (std::out_of_range& e) {
38202       {
38203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38204       };
38205     } catch (std::exception& e) {
38206       {
38207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38208       };
38209     } catch (Dali::DaliException e) {
38210       {
38211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38212       };
38213     } catch (...) {
38214       {
38215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38216       };
38217     }
38218   }
38219
38220   jresult = result;
38221   return jresult;
38222 }
38223
38224
38225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38226   void * jresult ;
38227   Dali::Vector4 *result = 0 ;
38228
38229   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38230   jresult = (void *)result;
38231   return jresult;
38232 }
38233
38234
38235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38236   void * jresult ;
38237   Dali::Vector4 *result = 0 ;
38238
38239   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38240   jresult = (void *)result;
38241   return jresult;
38242 }
38243
38244
38245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38246   void * jresult ;
38247   Dali::Stage *result = 0 ;
38248
38249   {
38250     try {
38251       result = (Dali::Stage *)new Dali::Stage();
38252     } catch (std::out_of_range& e) {
38253       {
38254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38255       };
38256     } catch (std::exception& e) {
38257       {
38258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38259       };
38260     } catch (Dali::DaliException e) {
38261       {
38262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38263       };
38264     } catch (...) {
38265       {
38266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38267       };
38268     }
38269   }
38270
38271   jresult = (void *)result;
38272   return jresult;
38273 }
38274
38275
38276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38277   void * jresult ;
38278   Dali::Stage result;
38279
38280   {
38281     try {
38282       result = Dali::Stage::GetCurrent();
38283     } catch (std::out_of_range& e) {
38284       {
38285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38286       };
38287     } catch (std::exception& e) {
38288       {
38289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38290       };
38291     } catch (Dali::DaliException e) {
38292       {
38293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38294       };
38295     } catch (...) {
38296       {
38297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38298       };
38299     }
38300   }
38301
38302   jresult = new Dali::Stage((const Dali::Stage &)result);
38303   return jresult;
38304 }
38305
38306
38307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38308   unsigned int jresult ;
38309   bool result;
38310
38311   {
38312     try {
38313       result = (bool)Dali::Stage::IsInstalled();
38314     } catch (std::out_of_range& e) {
38315       {
38316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38317       };
38318     } catch (std::exception& e) {
38319       {
38320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38321       };
38322     } catch (Dali::DaliException e) {
38323       {
38324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38325       };
38326     } catch (...) {
38327       {
38328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38329       };
38330     }
38331   }
38332
38333   jresult = result;
38334   return jresult;
38335 }
38336
38337
38338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38339   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38340
38341   arg1 = (Dali::Stage *)jarg1;
38342   {
38343     try {
38344       delete arg1;
38345     } catch (std::out_of_range& e) {
38346       {
38347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38348       };
38349     } catch (std::exception& e) {
38350       {
38351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38352       };
38353     } catch (Dali::DaliException e) {
38354       {
38355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38356       };
38357     } catch (...) {
38358       {
38359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38360       };
38361     }
38362   }
38363
38364 }
38365
38366
38367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38368   void * jresult ;
38369   Dali::Stage *arg1 = 0 ;
38370   Dali::Stage *result = 0 ;
38371
38372   arg1 = (Dali::Stage *)jarg1;
38373   if (!arg1) {
38374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38375     return 0;
38376   }
38377   {
38378     try {
38379       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38380     } catch (std::out_of_range& e) {
38381       {
38382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38383       };
38384     } catch (std::exception& e) {
38385       {
38386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38387       };
38388     } catch (Dali::DaliException e) {
38389       {
38390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38391       };
38392     } catch (...) {
38393       {
38394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38395       };
38396     }
38397   }
38398
38399   jresult = (void *)result;
38400   return jresult;
38401 }
38402
38403
38404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38405   void * jresult ;
38406   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38407   Dali::Stage *arg2 = 0 ;
38408   Dali::Stage *result = 0 ;
38409
38410   arg1 = (Dali::Stage *)jarg1;
38411   arg2 = (Dali::Stage *)jarg2;
38412   if (!arg2) {
38413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38414     return 0;
38415   }
38416   {
38417     try {
38418       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38419     } catch (std::out_of_range& e) {
38420       {
38421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38422       };
38423     } catch (std::exception& e) {
38424       {
38425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38426       };
38427     } catch (Dali::DaliException e) {
38428       {
38429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38430       };
38431     } catch (...) {
38432       {
38433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38434       };
38435     }
38436   }
38437
38438   jresult = (void *)result;
38439   return jresult;
38440 }
38441
38442
38443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38444   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38445   Dali::Actor *arg2 = 0 ;
38446
38447   arg1 = (Dali::Stage *)jarg1;
38448   arg2 = (Dali::Actor *)jarg2;
38449   if (!arg2) {
38450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38451     return ;
38452   }
38453   {
38454     try {
38455       (arg1)->Add(*arg2);
38456     } catch (std::out_of_range& e) {
38457       {
38458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38459       };
38460     } catch (std::exception& e) {
38461       {
38462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38463       };
38464     } catch (Dali::DaliException e) {
38465       {
38466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38467       };
38468     } catch (...) {
38469       {
38470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38471       };
38472     }
38473   }
38474
38475 }
38476
38477
38478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38479   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38480   Dali::Actor *arg2 = 0 ;
38481
38482   arg1 = (Dali::Stage *)jarg1;
38483   arg2 = (Dali::Actor *)jarg2;
38484   if (!arg2) {
38485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38486     return ;
38487   }
38488   {
38489     try {
38490       (arg1)->Remove(*arg2);
38491     } catch (std::out_of_range& e) {
38492       {
38493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38494       };
38495     } catch (std::exception& e) {
38496       {
38497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38498       };
38499     } catch (Dali::DaliException e) {
38500       {
38501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38502       };
38503     } catch (...) {
38504       {
38505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38506       };
38507     }
38508   }
38509
38510 }
38511
38512
38513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38514   void * jresult ;
38515   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38516   Dali::Vector2 result;
38517
38518   arg1 = (Dali::Stage *)jarg1;
38519   {
38520     try {
38521       result = ((Dali::Stage const *)arg1)->GetSize();
38522     } catch (std::out_of_range& e) {
38523       {
38524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38525       };
38526     } catch (std::exception& e) {
38527       {
38528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38529       };
38530     } catch (Dali::DaliException e) {
38531       {
38532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38533       };
38534     } catch (...) {
38535       {
38536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38537       };
38538     }
38539   }
38540
38541   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38542   return jresult;
38543 }
38544
38545
38546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38547   void * jresult ;
38548   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38549   Dali::RenderTaskList result;
38550
38551   arg1 = (Dali::Stage *)jarg1;
38552   {
38553     try {
38554       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38555     } catch (std::out_of_range& e) {
38556       {
38557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38558       };
38559     } catch (std::exception& e) {
38560       {
38561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38562       };
38563     } catch (Dali::DaliException e) {
38564       {
38565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38566       };
38567     } catch (...) {
38568       {
38569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38570       };
38571     }
38572   }
38573
38574   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38575   return jresult;
38576 }
38577
38578
38579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38580   unsigned int jresult ;
38581   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38582   unsigned int result;
38583
38584   arg1 = (Dali::Stage *)jarg1;
38585   {
38586     try {
38587       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38588     } catch (std::out_of_range& e) {
38589       {
38590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38591       };
38592     } catch (std::exception& e) {
38593       {
38594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38595       };
38596     } catch (Dali::DaliException e) {
38597       {
38598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38599       };
38600     } catch (...) {
38601       {
38602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38603       };
38604     }
38605   }
38606
38607   jresult = result;
38608   return jresult;
38609 }
38610
38611
38612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38613   void * jresult ;
38614   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38615   unsigned int arg2 ;
38616   Dali::Layer result;
38617
38618   arg1 = (Dali::Stage *)jarg1;
38619   arg2 = (unsigned int)jarg2;
38620   {
38621     try {
38622       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38623     } catch (std::out_of_range& e) {
38624       {
38625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38626       };
38627     } catch (std::exception& e) {
38628       {
38629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38630       };
38631     } catch (Dali::DaliException e) {
38632       {
38633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38634       };
38635     } catch (...) {
38636       {
38637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38638       };
38639     }
38640   }
38641
38642   jresult = new Dali::Layer((const Dali::Layer &)result);
38643   return jresult;
38644 }
38645
38646
38647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38648   void * jresult ;
38649   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38650   Dali::Layer result;
38651
38652   arg1 = (Dali::Stage *)jarg1;
38653   {
38654     try {
38655       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38656     } catch (std::out_of_range& e) {
38657       {
38658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38659       };
38660     } catch (std::exception& e) {
38661       {
38662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38663       };
38664     } catch (Dali::DaliException e) {
38665       {
38666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38667       };
38668     } catch (...) {
38669       {
38670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38671       };
38672     }
38673   }
38674
38675   jresult = new Dali::Layer((const Dali::Layer &)result);
38676   return jresult;
38677 }
38678
38679
38680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38681   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38682   Dali::Vector4 arg2 ;
38683   Dali::Vector4 *argp2 ;
38684
38685   arg1 = (Dali::Stage *)jarg1;
38686   argp2 = (Dali::Vector4 *)jarg2;
38687   if (!argp2) {
38688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38689     return ;
38690   }
38691   arg2 = *argp2;
38692   {
38693     try {
38694       (arg1)->SetBackgroundColor(arg2);
38695     } catch (std::out_of_range& e) {
38696       {
38697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38698       };
38699     } catch (std::exception& e) {
38700       {
38701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38702       };
38703     } catch (Dali::DaliException e) {
38704       {
38705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38706       };
38707     } catch (...) {
38708       {
38709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38710       };
38711     }
38712   }
38713
38714 }
38715
38716
38717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38718   void * jresult ;
38719   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38720   Dali::Vector4 result;
38721
38722   arg1 = (Dali::Stage *)jarg1;
38723   {
38724     try {
38725       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38726     } catch (std::out_of_range& e) {
38727       {
38728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38729       };
38730     } catch (std::exception& e) {
38731       {
38732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38733       };
38734     } catch (Dali::DaliException e) {
38735       {
38736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38737       };
38738     } catch (...) {
38739       {
38740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38741       };
38742     }
38743   }
38744
38745   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38746   return jresult;
38747 }
38748
38749
38750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38751   void * jresult ;
38752   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38753   Dali::Vector2 result;
38754
38755   arg1 = (Dali::Stage *)jarg1;
38756   {
38757     try {
38758       result = ((Dali::Stage const *)arg1)->GetDpi();
38759     } catch (std::out_of_range& e) {
38760       {
38761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38762       };
38763     } catch (std::exception& e) {
38764       {
38765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38766       };
38767     } catch (Dali::DaliException e) {
38768       {
38769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38770       };
38771     } catch (...) {
38772       {
38773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38774       };
38775     }
38776   }
38777
38778   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38779   return jresult;
38780 }
38781
38782
38783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38784   void * jresult ;
38785   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38786   Dali::ObjectRegistry result;
38787
38788   arg1 = (Dali::Stage *)jarg1;
38789   {
38790     try {
38791       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38792     } catch (std::out_of_range& e) {
38793       {
38794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38795       };
38796     } catch (std::exception& e) {
38797       {
38798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38799       };
38800     } catch (Dali::DaliException e) {
38801       {
38802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38803       };
38804     } catch (...) {
38805       {
38806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38807       };
38808     }
38809   }
38810
38811   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38812   return jresult;
38813 }
38814
38815
38816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38817   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38818   float arg2 ;
38819
38820   arg1 = (Dali::Stage *)jarg1;
38821   arg2 = (float)jarg2;
38822   {
38823     try {
38824       (arg1)->KeepRendering(arg2);
38825     } catch (std::out_of_range& e) {
38826       {
38827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38828       };
38829     } catch (std::exception& e) {
38830       {
38831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38832       };
38833     } catch (Dali::DaliException e) {
38834       {
38835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38836       };
38837     } catch (...) {
38838       {
38839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38840       };
38841     }
38842   }
38843
38844 }
38845
38846
38847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38848   void * jresult ;
38849   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38850   Dali::Stage::KeyEventSignalType *result = 0 ;
38851
38852   arg1 = (Dali::Stage *)jarg1;
38853   {
38854     try {
38855       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38856     } catch (std::out_of_range& e) {
38857       {
38858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38859       };
38860     } catch (std::exception& e) {
38861       {
38862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38863       };
38864     } catch (Dali::DaliException e) {
38865       {
38866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38867       };
38868     } catch (...) {
38869       {
38870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38871       };
38872     }
38873   }
38874
38875   jresult = (void *)result;
38876   return jresult;
38877 }
38878
38879
38880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38881   void * jresult ;
38882   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38883   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38884
38885   arg1 = (Dali::Stage *)jarg1;
38886   {
38887     try {
38888       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38889     } catch (std::out_of_range& e) {
38890       {
38891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38892       };
38893     } catch (std::exception& e) {
38894       {
38895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38896       };
38897     } catch (Dali::DaliException e) {
38898       {
38899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38900       };
38901     } catch (...) {
38902       {
38903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38904       };
38905     }
38906   }
38907
38908   jresult = (void *)result;
38909   return jresult;
38910 }
38911
38912
38913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38914   void * jresult ;
38915   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38916   Dali::Stage::TouchSignalType *result = 0 ;
38917
38918   arg1 = (Dali::Stage *)jarg1;
38919   {
38920     try {
38921       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38922     } catch (std::out_of_range& e) {
38923       {
38924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38925       };
38926     } catch (std::exception& e) {
38927       {
38928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38929       };
38930     } catch (Dali::DaliException e) {
38931       {
38932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38933       };
38934     } catch (...) {
38935       {
38936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38937       };
38938     }
38939   }
38940
38941   jresult = (void *)result;
38942   return jresult;
38943 }
38944
38945
38946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38947   void * jresult ;
38948   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38949   Dali::Stage::WheelEventSignalType *result = 0 ;
38950
38951   arg1 = (Dali::Stage *)jarg1;
38952   {
38953     try {
38954       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38955     } catch (std::out_of_range& e) {
38956       {
38957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38958       };
38959     } catch (std::exception& e) {
38960       {
38961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38962       };
38963     } catch (Dali::DaliException e) {
38964       {
38965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38966       };
38967     } catch (...) {
38968       {
38969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38970       };
38971     }
38972   }
38973
38974   jresult = (void *)result;
38975   return jresult;
38976 }
38977
38978
38979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38980   void * jresult ;
38981   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38982   Dali::Stage::ContextStatusSignal *result = 0 ;
38983
38984   arg1 = (Dali::Stage *)jarg1;
38985   {
38986     try {
38987       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38988     } catch (std::out_of_range& e) {
38989       {
38990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38991       };
38992     } catch (std::exception& e) {
38993       {
38994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38995       };
38996     } catch (Dali::DaliException e) {
38997       {
38998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38999       };
39000     } catch (...) {
39001       {
39002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39003       };
39004     }
39005   }
39006
39007   jresult = (void *)result;
39008   return jresult;
39009 }
39010
39011
39012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39013   void * jresult ;
39014   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39015   Dali::Stage::ContextStatusSignal *result = 0 ;
39016
39017   arg1 = (Dali::Stage *)jarg1;
39018   {
39019     try {
39020       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39021     } catch (std::out_of_range& e) {
39022       {
39023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39024       };
39025     } catch (std::exception& e) {
39026       {
39027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39028       };
39029     } catch (Dali::DaliException e) {
39030       {
39031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39032       };
39033     } catch (...) {
39034       {
39035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39036       };
39037     }
39038   }
39039
39040   jresult = (void *)result;
39041   return jresult;
39042 }
39043
39044
39045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39046   void * jresult ;
39047   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39048   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39049
39050   arg1 = (Dali::Stage *)jarg1;
39051   {
39052     try {
39053       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39054     } catch (std::out_of_range& e) {
39055       {
39056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39057       };
39058     } catch (std::exception& e) {
39059       {
39060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39061       };
39062     } catch (Dali::DaliException e) {
39063       {
39064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39065       };
39066     } catch (...) {
39067       {
39068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39069       };
39070     }
39071   }
39072
39073   jresult = (void *)result;
39074   return jresult;
39075 }
39076
39077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39078   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39079   Dali::DevelStage::Rendering arg2 ;
39080
39081   arg1 = (Dali::Stage *)jarg1;
39082   arg2 = (Dali::DevelStage::Rendering)jarg2;
39083   {
39084     try {
39085       DevelStage::SetRenderingBehavior(*arg1,arg2);
39086     } catch (std::out_of_range& e) {
39087       {
39088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39089       };
39090     } catch (std::exception& e) {
39091       {
39092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39093       };
39094     } catch (Dali::DaliException e) {
39095       {
39096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39097       };
39098     } catch (...) {
39099       {
39100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39101       };
39102     }
39103   }
39104
39105 }
39106
39107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39108
39109   int jresult ;
39110   int result ;
39111   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39112
39113   arg1 = (Dali::Stage *)jarg1;
39114   {
39115     try {
39116       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39117     } catch (std::out_of_range& e) {
39118       {
39119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39120       };
39121     } catch (std::exception& e) {
39122       {
39123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39124       };
39125     } catch (Dali::DaliException e) {
39126       {
39127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39128       };
39129     } catch (...) {
39130       {
39131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39132       };
39133     }
39134   }
39135
39136   jresult = result;
39137   return jresult;
39138 }
39139
39140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39141   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39142
39143   arg1 = (Dali::RelayoutContainer *)jarg1;
39144   {
39145     try {
39146       delete arg1;
39147     } catch (std::out_of_range& e) {
39148       {
39149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39150       };
39151     } catch (std::exception& e) {
39152       {
39153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39154       };
39155     } catch (Dali::DaliException e) {
39156       {
39157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39158       };
39159     } catch (...) {
39160       {
39161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39162       };
39163     }
39164   }
39165
39166 }
39167
39168
39169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39170   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39171   Dali::Actor *arg2 = 0 ;
39172   Dali::Vector2 *arg3 = 0 ;
39173
39174   arg1 = (Dali::RelayoutContainer *)jarg1;
39175   arg2 = (Dali::Actor *)jarg2;
39176   if (!arg2) {
39177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39178     return ;
39179   }
39180   arg3 = (Dali::Vector2 *)jarg3;
39181   if (!arg3) {
39182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39183     return ;
39184   }
39185   {
39186     try {
39187       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39188     } catch (std::out_of_range& e) {
39189       {
39190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39191       };
39192     } catch (std::exception& e) {
39193       {
39194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39195       };
39196     } catch (Dali::DaliException e) {
39197       {
39198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39199       };
39200     } catch (...) {
39201       {
39202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39203       };
39204     }
39205   }
39206
39207 }
39208
39209
39210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39211   void * jresult ;
39212   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39213   Dali::CustomActor result;
39214
39215   arg1 = (Dali::CustomActorImpl *)jarg1;
39216   {
39217     try {
39218       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39219     } catch (std::out_of_range& e) {
39220       {
39221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39222       };
39223     } catch (std::exception& e) {
39224       {
39225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39226       };
39227     } catch (Dali::DaliException e) {
39228       {
39229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39230       };
39231     } catch (...) {
39232       {
39233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39234       };
39235     }
39236   }
39237
39238   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39239   return jresult;
39240 }
39241
39242
39243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39244   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39245   int arg2 ;
39246
39247   arg1 = (Dali::CustomActorImpl *)jarg1;
39248   arg2 = (int)jarg2;
39249   {
39250     try {
39251       (arg1)->OnStageConnection(arg2);
39252     } catch (std::out_of_range& e) {
39253       {
39254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39255       };
39256     } catch (std::exception& e) {
39257       {
39258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39259       };
39260     } catch (Dali::DaliException e) {
39261       {
39262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39263       };
39264     } catch (...) {
39265       {
39266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39267       };
39268     }
39269   }
39270
39271 }
39272
39273
39274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39275   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39276
39277   arg1 = (Dali::CustomActorImpl *)jarg1;
39278   {
39279     try {
39280       (arg1)->OnStageDisconnection();
39281     } catch (std::out_of_range& e) {
39282       {
39283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39284       };
39285     } catch (std::exception& e) {
39286       {
39287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39288       };
39289     } catch (Dali::DaliException e) {
39290       {
39291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39292       };
39293     } catch (...) {
39294       {
39295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39296       };
39297     }
39298   }
39299
39300 }
39301
39302
39303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39304   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39305   Dali::Actor *arg2 = 0 ;
39306
39307   arg1 = (Dali::CustomActorImpl *)jarg1;
39308   arg2 = (Dali::Actor *)jarg2;
39309   if (!arg2) {
39310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39311     return ;
39312   }
39313   {
39314     try {
39315       (arg1)->OnChildAdd(*arg2);
39316     } catch (std::out_of_range& e) {
39317       {
39318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39319       };
39320     } catch (std::exception& e) {
39321       {
39322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39323       };
39324     } catch (Dali::DaliException e) {
39325       {
39326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39327       };
39328     } catch (...) {
39329       {
39330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39331       };
39332     }
39333   }
39334
39335 }
39336
39337
39338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39339   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39340   Dali::Actor *arg2 = 0 ;
39341
39342   arg1 = (Dali::CustomActorImpl *)jarg1;
39343   arg2 = (Dali::Actor *)jarg2;
39344   if (!arg2) {
39345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39346     return ;
39347   }
39348   {
39349     try {
39350       (arg1)->OnChildRemove(*arg2);
39351     } catch (std::out_of_range& e) {
39352       {
39353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39354       };
39355     } catch (std::exception& e) {
39356       {
39357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39358       };
39359     } catch (Dali::DaliException e) {
39360       {
39361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39362       };
39363     } catch (...) {
39364       {
39365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39366       };
39367     }
39368   }
39369
39370 }
39371
39372
39373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39374   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39375   Dali::Property::Index arg2 ;
39376   Dali::Property::Value arg3 ;
39377   Dali::Property::Value *argp3 ;
39378
39379   arg1 = (Dali::CustomActorImpl *)jarg1;
39380   arg2 = (Dali::Property::Index)jarg2;
39381   argp3 = (Dali::Property::Value *)jarg3;
39382   if (!argp3) {
39383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39384     return ;
39385   }
39386   arg3 = *argp3;
39387   {
39388     try {
39389       (arg1)->OnPropertySet(arg2,arg3);
39390     } catch (std::out_of_range& e) {
39391       {
39392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39393       };
39394     } catch (std::exception& e) {
39395       {
39396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39397       };
39398     } catch (Dali::DaliException e) {
39399       {
39400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39401       };
39402     } catch (...) {
39403       {
39404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39405       };
39406     }
39407   }
39408
39409 }
39410
39411
39412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39413   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39414   Dali::Vector3 *arg2 = 0 ;
39415
39416   arg1 = (Dali::CustomActorImpl *)jarg1;
39417   arg2 = (Dali::Vector3 *)jarg2;
39418   if (!arg2) {
39419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39420     return ;
39421   }
39422   {
39423     try {
39424       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39425     } catch (std::out_of_range& e) {
39426       {
39427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39428       };
39429     } catch (std::exception& e) {
39430       {
39431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39432       };
39433     } catch (Dali::DaliException e) {
39434       {
39435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39436       };
39437     } catch (...) {
39438       {
39439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39440       };
39441     }
39442   }
39443
39444 }
39445
39446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39447   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39448   Dali::Animation *arg2 = 0 ;
39449   Dali::Vector3 *arg3 = 0 ;
39450
39451   arg1 = (Dali::CustomActorImpl *)jarg1;
39452   arg2 = (Dali::Animation *)jarg2;
39453   if (!arg2) {
39454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39455     return ;
39456   }
39457   arg3 = (Dali::Vector3 *)jarg3;
39458   if (!arg3) {
39459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39460     return ;
39461   }
39462   {
39463     try {
39464       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39465     } catch (std::out_of_range& e) {
39466       {
39467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39468       };
39469     } catch (std::exception& e) {
39470       {
39471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39472       };
39473     } catch (Dali::DaliException e) {
39474       {
39475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39476       };
39477     } catch (...) {
39478       {
39479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39480       };
39481     }
39482   }
39483
39484 }
39485
39486
39487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39488   unsigned int jresult ;
39489   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39490   Dali::TouchEvent *arg2 = 0 ;
39491   bool result;
39492
39493   arg1 = (Dali::CustomActorImpl *)jarg1;
39494   arg2 = (Dali::TouchEvent *)jarg2;
39495   if (!arg2) {
39496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39497     return 0;
39498   }
39499   {
39500     try {
39501       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39502     } catch (std::out_of_range& e) {
39503       {
39504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39505       };
39506     } catch (std::exception& e) {
39507       {
39508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39509       };
39510     } catch (Dali::DaliException e) {
39511       {
39512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39513       };
39514     } catch (...) {
39515       {
39516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39517       };
39518     }
39519   }
39520
39521   jresult = result;
39522   return jresult;
39523 }
39524
39525
39526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39527   unsigned int jresult ;
39528   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39529   Dali::HoverEvent *arg2 = 0 ;
39530   bool result;
39531
39532   arg1 = (Dali::CustomActorImpl *)jarg1;
39533   arg2 = (Dali::HoverEvent *)jarg2;
39534   if (!arg2) {
39535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39536     return 0;
39537   }
39538   {
39539     try {
39540       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39541     } catch (std::out_of_range& e) {
39542       {
39543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39544       };
39545     } catch (std::exception& e) {
39546       {
39547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39548       };
39549     } catch (Dali::DaliException e) {
39550       {
39551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39552       };
39553     } catch (...) {
39554       {
39555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39556       };
39557     }
39558   }
39559
39560   jresult = result;
39561   return jresult;
39562 }
39563
39564
39565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39566   unsigned int jresult ;
39567   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39568   Dali::KeyEvent *arg2 = 0 ;
39569   bool result;
39570
39571   arg1 = (Dali::CustomActorImpl *)jarg1;
39572   arg2 = (Dali::KeyEvent *)jarg2;
39573   if (!arg2) {
39574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39575     return 0;
39576   }
39577   {
39578     try {
39579       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39580     } catch (std::out_of_range& e) {
39581       {
39582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39583       };
39584     } catch (std::exception& e) {
39585       {
39586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39587       };
39588     } catch (Dali::DaliException e) {
39589       {
39590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39591       };
39592     } catch (...) {
39593       {
39594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39595       };
39596     }
39597   }
39598
39599   jresult = result;
39600   return jresult;
39601 }
39602
39603
39604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39605   unsigned int jresult ;
39606   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39607   Dali::WheelEvent *arg2 = 0 ;
39608   bool result;
39609
39610   arg1 = (Dali::CustomActorImpl *)jarg1;
39611   arg2 = (Dali::WheelEvent *)jarg2;
39612   if (!arg2) {
39613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39614     return 0;
39615   }
39616   {
39617     try {
39618       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39619     } catch (std::out_of_range& e) {
39620       {
39621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39622       };
39623     } catch (std::exception& e) {
39624       {
39625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39626       };
39627     } catch (Dali::DaliException e) {
39628       {
39629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39630       };
39631     } catch (...) {
39632       {
39633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39634       };
39635     }
39636   }
39637
39638   jresult = result;
39639   return jresult;
39640 }
39641
39642
39643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39644   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39645   Dali::Vector2 *arg2 = 0 ;
39646   Dali::RelayoutContainer *arg3 = 0 ;
39647
39648   arg1 = (Dali::CustomActorImpl *)jarg1;
39649   arg2 = (Dali::Vector2 *)jarg2;
39650   if (!arg2) {
39651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39652     return ;
39653   }
39654   arg3 = (Dali::RelayoutContainer *)jarg3;
39655   if (!arg3) {
39656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39657     return ;
39658   }
39659   {
39660     try {
39661       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39662     } catch (std::out_of_range& e) {
39663       {
39664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39665       };
39666     } catch (std::exception& e) {
39667       {
39668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39669       };
39670     } catch (Dali::DaliException e) {
39671       {
39672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39673       };
39674     } catch (...) {
39675       {
39676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39677       };
39678     }
39679   }
39680
39681 }
39682
39683
39684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39685   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39686   Dali::ResizePolicy::Type arg2 ;
39687   Dali::Dimension::Type arg3 ;
39688
39689   arg1 = (Dali::CustomActorImpl *)jarg1;
39690   arg2 = (Dali::ResizePolicy::Type)jarg2;
39691   arg3 = (Dali::Dimension::Type)jarg3;
39692   {
39693     try {
39694       (arg1)->OnSetResizePolicy(arg2,arg3);
39695     } catch (std::out_of_range& e) {
39696       {
39697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39698       };
39699     } catch (std::exception& e) {
39700       {
39701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39702       };
39703     } catch (Dali::DaliException e) {
39704       {
39705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39706       };
39707     } catch (...) {
39708       {
39709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39710       };
39711     }
39712   }
39713
39714 }
39715
39716
39717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39718   void * jresult ;
39719   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39720   Dali::Vector3 result;
39721
39722   arg1 = (Dali::CustomActorImpl *)jarg1;
39723   {
39724     try {
39725       result = (arg1)->GetNaturalSize();
39726     } catch (std::out_of_range& e) {
39727       {
39728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39729       };
39730     } catch (std::exception& e) {
39731       {
39732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39733       };
39734     } catch (Dali::DaliException e) {
39735       {
39736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39737       };
39738     } catch (...) {
39739       {
39740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39741       };
39742     }
39743   }
39744
39745   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39746   return jresult;
39747 }
39748
39749
39750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39751   float jresult ;
39752   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39753   Dali::Actor *arg2 = 0 ;
39754   Dali::Dimension::Type arg3 ;
39755   float result;
39756
39757   arg1 = (Dali::CustomActorImpl *)jarg1;
39758   arg2 = (Dali::Actor *)jarg2;
39759   if (!arg2) {
39760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39761     return 0;
39762   }
39763   arg3 = (Dali::Dimension::Type)jarg3;
39764   {
39765     try {
39766       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39767     } catch (std::out_of_range& e) {
39768       {
39769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39770       };
39771     } catch (std::exception& e) {
39772       {
39773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39774       };
39775     } catch (Dali::DaliException e) {
39776       {
39777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39778       };
39779     } catch (...) {
39780       {
39781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39782       };
39783     }
39784   }
39785
39786   jresult = result;
39787   return jresult;
39788 }
39789
39790
39791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39792   float jresult ;
39793   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39794   float arg2 ;
39795   float result;
39796
39797   arg1 = (Dali::CustomActorImpl *)jarg1;
39798   arg2 = (float)jarg2;
39799   {
39800     try {
39801       result = (float)(arg1)->GetHeightForWidth(arg2);
39802     } catch (std::out_of_range& e) {
39803       {
39804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39805       };
39806     } catch (std::exception& e) {
39807       {
39808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39809       };
39810     } catch (Dali::DaliException e) {
39811       {
39812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39813       };
39814     } catch (...) {
39815       {
39816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39817       };
39818     }
39819   }
39820
39821   jresult = result;
39822   return jresult;
39823 }
39824
39825
39826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39827   float jresult ;
39828   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39829   float arg2 ;
39830   float result;
39831
39832   arg1 = (Dali::CustomActorImpl *)jarg1;
39833   arg2 = (float)jarg2;
39834   {
39835     try {
39836       result = (float)(arg1)->GetWidthForHeight(arg2);
39837     } catch (std::out_of_range& e) {
39838       {
39839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39840       };
39841     } catch (std::exception& e) {
39842       {
39843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39844       };
39845     } catch (Dali::DaliException e) {
39846       {
39847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39848       };
39849     } catch (...) {
39850       {
39851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39852       };
39853     }
39854   }
39855
39856   jresult = result;
39857   return jresult;
39858 }
39859
39860
39861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39862   unsigned int jresult ;
39863   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39864   Dali::Dimension::Type arg2 ;
39865   bool result;
39866
39867   arg1 = (Dali::CustomActorImpl *)jarg1;
39868   arg2 = (Dali::Dimension::Type)jarg2;
39869   {
39870     try {
39871       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39872     } catch (std::out_of_range& e) {
39873       {
39874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39875       };
39876     } catch (std::exception& e) {
39877       {
39878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39879       };
39880     } catch (Dali::DaliException e) {
39881       {
39882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39883       };
39884     } catch (...) {
39885       {
39886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39887       };
39888     }
39889   }
39890
39891   jresult = result;
39892   return jresult;
39893 }
39894
39895
39896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39897   unsigned int jresult ;
39898   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39899   bool result;
39900
39901   arg1 = (Dali::CustomActorImpl *)jarg1;
39902   {
39903     try {
39904       result = (bool)(arg1)->RelayoutDependentOnChildren();
39905     } catch (std::out_of_range& e) {
39906       {
39907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39908       };
39909     } catch (std::exception& e) {
39910       {
39911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39912       };
39913     } catch (Dali::DaliException e) {
39914       {
39915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39916       };
39917     } catch (...) {
39918       {
39919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39920       };
39921     }
39922   }
39923
39924   jresult = result;
39925   return jresult;
39926 }
39927
39928
39929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39930   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39931   Dali::Dimension::Type arg2 ;
39932
39933   arg1 = (Dali::CustomActorImpl *)jarg1;
39934   arg2 = (Dali::Dimension::Type)jarg2;
39935   {
39936     try {
39937       (arg1)->OnCalculateRelayoutSize(arg2);
39938     } catch (std::out_of_range& e) {
39939       {
39940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39941       };
39942     } catch (std::exception& e) {
39943       {
39944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39945       };
39946     } catch (Dali::DaliException e) {
39947       {
39948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39949       };
39950     } catch (...) {
39951       {
39952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39953       };
39954     }
39955   }
39956
39957 }
39958
39959
39960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39961   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39962   float arg2 ;
39963   Dali::Dimension::Type arg3 ;
39964
39965   arg1 = (Dali::CustomActorImpl *)jarg1;
39966   arg2 = (float)jarg2;
39967   arg3 = (Dali::Dimension::Type)jarg3;
39968   {
39969     try {
39970       (arg1)->OnLayoutNegotiated(arg2,arg3);
39971     } catch (std::out_of_range& e) {
39972       {
39973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39974       };
39975     } catch (std::exception& e) {
39976       {
39977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39978       };
39979     } catch (Dali::DaliException e) {
39980       {
39981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39982       };
39983     } catch (...) {
39984       {
39985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39986       };
39987     }
39988   }
39989
39990 }
39991
39992
39993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39994   unsigned int jresult ;
39995   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39996   bool result;
39997
39998   arg1 = (Dali::CustomActorImpl *)jarg1;
39999   {
40000     try {
40001       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40002     } catch (std::out_of_range& e) {
40003       {
40004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40005       };
40006     } catch (std::exception& e) {
40007       {
40008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40009       };
40010     } catch (Dali::DaliException e) {
40011       {
40012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40013       };
40014     } catch (...) {
40015       {
40016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40017       };
40018     }
40019   }
40020
40021   jresult = result;
40022   return jresult;
40023 }
40024
40025
40026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40027   unsigned int jresult ;
40028   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40029   bool result;
40030
40031   arg1 = (Dali::CustomActorImpl *)jarg1;
40032   {
40033     try {
40034       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40035     } catch (std::out_of_range& e) {
40036       {
40037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40038       };
40039     } catch (std::exception& e) {
40040       {
40041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40042       };
40043     } catch (Dali::DaliException e) {
40044       {
40045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40046       };
40047     } catch (...) {
40048       {
40049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40050       };
40051     }
40052   }
40053
40054   jresult = result;
40055   return jresult;
40056 }
40057
40058
40059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40060   unsigned int jresult ;
40061   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40062   bool result;
40063
40064   arg1 = (Dali::CustomActorImpl *)jarg1;
40065   {
40066     try {
40067       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40068     } catch (std::out_of_range& e) {
40069       {
40070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40071       };
40072     } catch (std::exception& e) {
40073       {
40074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40075       };
40076     } catch (Dali::DaliException e) {
40077       {
40078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40079       };
40080     } catch (...) {
40081       {
40082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40083       };
40084     }
40085   }
40086
40087   jresult = result;
40088   return jresult;
40089 }
40090
40091
40092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40093   unsigned int jresult ;
40094   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40095   bool result;
40096
40097   arg1 = (Dali::CustomActorImpl *)jarg1;
40098   {
40099     try {
40100       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40101     } catch (std::out_of_range& e) {
40102       {
40103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40104       };
40105     } catch (std::exception& e) {
40106       {
40107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40108       };
40109     } catch (Dali::DaliException e) {
40110       {
40111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40112       };
40113     } catch (...) {
40114       {
40115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40116       };
40117     }
40118   }
40119
40120   jresult = result;
40121   return jresult;
40122 }
40123
40124
40125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40126   void * jresult ;
40127   Dali::CustomActor *result = 0 ;
40128
40129   {
40130     try {
40131       result = (Dali::CustomActor *)new Dali::CustomActor();
40132     } catch (std::out_of_range& e) {
40133       {
40134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40135       };
40136     } catch (std::exception& e) {
40137       {
40138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40139       };
40140     } catch (Dali::DaliException e) {
40141       {
40142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40143       };
40144     } catch (...) {
40145       {
40146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40147       };
40148     }
40149   }
40150
40151   jresult = (void *)result;
40152   return jresult;
40153 }
40154
40155
40156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40157   void * jresult ;
40158   Dali::BaseHandle arg1 ;
40159   Dali::BaseHandle *argp1 ;
40160   Dali::CustomActor result;
40161
40162   argp1 = (Dali::BaseHandle *)jarg1;
40163   if (!argp1) {
40164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40165     return 0;
40166   }
40167   arg1 = *argp1;
40168   {
40169     try {
40170       result = Dali::CustomActor::DownCast(arg1);
40171     } catch (std::out_of_range& e) {
40172       {
40173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40174       };
40175     } catch (std::exception& e) {
40176       {
40177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40178       };
40179     } catch (Dali::DaliException e) {
40180       {
40181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40182       };
40183     } catch (...) {
40184       {
40185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40186       };
40187     }
40188   }
40189
40190   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40191   return jresult;
40192 }
40193
40194
40195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40196   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40197
40198   arg1 = (Dali::CustomActor *)jarg1;
40199   {
40200     try {
40201       delete arg1;
40202     } catch (std::out_of_range& e) {
40203       {
40204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40205       };
40206     } catch (std::exception& e) {
40207       {
40208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40209       };
40210     } catch (Dali::DaliException e) {
40211       {
40212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40213       };
40214     } catch (...) {
40215       {
40216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40217       };
40218     }
40219   }
40220
40221 }
40222
40223
40224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40225   void * jresult ;
40226   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40227   Dali::CustomActorImpl *result = 0 ;
40228
40229   arg1 = (Dali::CustomActor *)jarg1;
40230   {
40231     try {
40232       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40233     } catch (std::out_of_range& e) {
40234       {
40235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40236       };
40237     } catch (std::exception& e) {
40238       {
40239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40240       };
40241     } catch (Dali::DaliException e) {
40242       {
40243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40244       };
40245     } catch (...) {
40246       {
40247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40248       };
40249     }
40250   }
40251
40252   jresult = (void *)result;
40253   return jresult;
40254 }
40255
40256
40257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40258   void * jresult ;
40259   Dali::CustomActorImpl *arg1 = 0 ;
40260   Dali::CustomActor *result = 0 ;
40261
40262   arg1 = (Dali::CustomActorImpl *)jarg1;
40263   if (!arg1) {
40264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40265     return 0;
40266   }
40267   {
40268     try {
40269       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40270     } catch (std::out_of_range& e) {
40271       {
40272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40273       };
40274     } catch (std::exception& e) {
40275       {
40276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40277       };
40278     } catch (Dali::DaliException e) {
40279       {
40280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40281       };
40282     } catch (...) {
40283       {
40284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40285       };
40286     }
40287   }
40288
40289   jresult = (void *)result;
40290   return jresult;
40291 }
40292
40293
40294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40295   void * jresult ;
40296   Dali::CustomActor *arg1 = 0 ;
40297   Dali::CustomActor *result = 0 ;
40298
40299   arg1 = (Dali::CustomActor *)jarg1;
40300   if (!arg1) {
40301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40302     return 0;
40303   }
40304   {
40305     try {
40306       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40307     } catch (std::out_of_range& e) {
40308       {
40309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40310       };
40311     } catch (std::exception& e) {
40312       {
40313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40314       };
40315     } catch (Dali::DaliException e) {
40316       {
40317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40318       };
40319     } catch (...) {
40320       {
40321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40322       };
40323     }
40324   }
40325
40326   jresult = (void *)result;
40327   return jresult;
40328 }
40329
40330
40331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40332   void * jresult ;
40333   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40334   Dali::CustomActor *arg2 = 0 ;
40335   Dali::CustomActor *result = 0 ;
40336
40337   arg1 = (Dali::CustomActor *)jarg1;
40338   arg2 = (Dali::CustomActor *)jarg2;
40339   if (!arg2) {
40340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40341     return 0;
40342   }
40343   {
40344     try {
40345       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40346     } catch (std::out_of_range& e) {
40347       {
40348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40349       };
40350     } catch (std::exception& e) {
40351       {
40352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40353       };
40354     } catch (Dali::DaliException e) {
40355       {
40356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40357       };
40358     } catch (...) {
40359       {
40360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40361       };
40362     }
40363   }
40364
40365   jresult = (void *)result;
40366   return jresult;
40367 }
40368
40369
40370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40371   int jresult ;
40372   int result;
40373
40374   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40375   jresult = (int)result;
40376   return jresult;
40377 }
40378
40379
40380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40381   int jresult ;
40382   int result;
40383
40384   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40385   jresult = (int)result;
40386   return jresult;
40387 }
40388
40389
40390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40391   int jresult ;
40392   int result;
40393
40394   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40395   jresult = (int)result;
40396   return jresult;
40397 }
40398
40399
40400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40401   int jresult ;
40402   int result;
40403
40404   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40405   jresult = (int)result;
40406   return jresult;
40407 }
40408
40409
40410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40411   int jresult ;
40412   int result;
40413
40414   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40415   jresult = (int)result;
40416   return jresult;
40417 }
40418
40419
40420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40421   int jresult ;
40422   int result;
40423
40424   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40425   jresult = (int)result;
40426   return jresult;
40427 }
40428
40429
40430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40431   int jresult ;
40432   int result;
40433
40434   result = (int)Dali::PanGestureDetector::Property::PANNING;
40435   jresult = (int)result;
40436   return jresult;
40437 }
40438
40439
40440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40441   void * jresult ;
40442   Dali::PanGestureDetector::Property *result = 0 ;
40443
40444   {
40445     try {
40446       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40447     } catch (std::out_of_range& e) {
40448       {
40449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40450       };
40451     } catch (std::exception& e) {
40452       {
40453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40454       };
40455     } catch (Dali::DaliException e) {
40456       {
40457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40458       };
40459     } catch (...) {
40460       {
40461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40462       };
40463     }
40464   }
40465
40466   jresult = (void *)result;
40467   return jresult;
40468 }
40469
40470
40471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40472   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40473
40474   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40475   {
40476     try {
40477       delete arg1;
40478     } catch (std::out_of_range& e) {
40479       {
40480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40481       };
40482     } catch (std::exception& e) {
40483       {
40484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40485       };
40486     } catch (Dali::DaliException e) {
40487       {
40488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40489       };
40490     } catch (...) {
40491       {
40492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40493       };
40494     }
40495   }
40496
40497 }
40498
40499
40500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40501   void * jresult ;
40502   Dali::Radian *result = 0 ;
40503
40504   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40505   jresult = (void *)result;
40506   return jresult;
40507 }
40508
40509
40510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40511   void * jresult ;
40512   Dali::Radian *result = 0 ;
40513
40514   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40515   jresult = (void *)result;
40516   return jresult;
40517 }
40518
40519
40520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40521   void * jresult ;
40522   Dali::Radian *result = 0 ;
40523
40524   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40525   jresult = (void *)result;
40526   return jresult;
40527 }
40528
40529
40530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40531   void * jresult ;
40532   Dali::Radian *result = 0 ;
40533
40534   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40535   jresult = (void *)result;
40536   return jresult;
40537 }
40538
40539
40540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40541   void * jresult ;
40542   Dali::Radian *result = 0 ;
40543
40544   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40545   jresult = (void *)result;
40546   return jresult;
40547 }
40548
40549
40550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40551   void * jresult ;
40552   Dali::Radian *result = 0 ;
40553
40554   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40555   jresult = (void *)result;
40556   return jresult;
40557 }
40558
40559
40560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40561   void * jresult ;
40562   Dali::Radian *result = 0 ;
40563
40564   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40565   jresult = (void *)result;
40566   return jresult;
40567 }
40568
40569
40570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40571   void * jresult ;
40572   Dali::PanGestureDetector *result = 0 ;
40573
40574   {
40575     try {
40576       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40577     } catch (std::out_of_range& e) {
40578       {
40579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40580       };
40581     } catch (std::exception& e) {
40582       {
40583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40584       };
40585     } catch (Dali::DaliException e) {
40586       {
40587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40588       };
40589     } catch (...) {
40590       {
40591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40592       };
40593     }
40594   }
40595
40596   jresult = (void *)result;
40597   return jresult;
40598 }
40599
40600
40601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40602   void * jresult ;
40603   Dali::PanGestureDetector result;
40604
40605   {
40606     try {
40607       result = Dali::PanGestureDetector::New();
40608     } catch (std::out_of_range& e) {
40609       {
40610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40611       };
40612     } catch (std::exception& e) {
40613       {
40614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40615       };
40616     } catch (Dali::DaliException e) {
40617       {
40618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40619       };
40620     } catch (...) {
40621       {
40622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40623       };
40624     }
40625   }
40626
40627   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40628   return jresult;
40629 }
40630
40631
40632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40633   void * jresult ;
40634   Dali::BaseHandle arg1 ;
40635   Dali::BaseHandle *argp1 ;
40636   Dali::PanGestureDetector result;
40637
40638   argp1 = (Dali::BaseHandle *)jarg1;
40639   if (!argp1) {
40640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40641     return 0;
40642   }
40643   arg1 = *argp1;
40644   {
40645     try {
40646       result = Dali::PanGestureDetector::DownCast(arg1);
40647     } catch (std::out_of_range& e) {
40648       {
40649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40650       };
40651     } catch (std::exception& e) {
40652       {
40653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40654       };
40655     } catch (Dali::DaliException e) {
40656       {
40657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40658       };
40659     } catch (...) {
40660       {
40661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40662       };
40663     }
40664   }
40665
40666   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40667   return jresult;
40668 }
40669
40670
40671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40672   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40673
40674   arg1 = (Dali::PanGestureDetector *)jarg1;
40675   {
40676     try {
40677       delete arg1;
40678     } catch (std::out_of_range& e) {
40679       {
40680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40681       };
40682     } catch (std::exception& e) {
40683       {
40684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40685       };
40686     } catch (Dali::DaliException e) {
40687       {
40688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40689       };
40690     } catch (...) {
40691       {
40692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40693       };
40694     }
40695   }
40696
40697 }
40698
40699
40700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40701   void * jresult ;
40702   Dali::PanGestureDetector *arg1 = 0 ;
40703   Dali::PanGestureDetector *result = 0 ;
40704
40705   arg1 = (Dali::PanGestureDetector *)jarg1;
40706   if (!arg1) {
40707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40708     return 0;
40709   }
40710   {
40711     try {
40712       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40713     } catch (std::out_of_range& e) {
40714       {
40715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40716       };
40717     } catch (std::exception& e) {
40718       {
40719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40720       };
40721     } catch (Dali::DaliException e) {
40722       {
40723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40724       };
40725     } catch (...) {
40726       {
40727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40728       };
40729     }
40730   }
40731
40732   jresult = (void *)result;
40733   return jresult;
40734 }
40735
40736
40737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40738   void * jresult ;
40739   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40740   Dali::PanGestureDetector *arg2 = 0 ;
40741   Dali::PanGestureDetector *result = 0 ;
40742
40743   arg1 = (Dali::PanGestureDetector *)jarg1;
40744   arg2 = (Dali::PanGestureDetector *)jarg2;
40745   if (!arg2) {
40746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40747     return 0;
40748   }
40749   {
40750     try {
40751       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40752     } catch (std::out_of_range& e) {
40753       {
40754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40755       };
40756     } catch (std::exception& e) {
40757       {
40758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40759       };
40760     } catch (Dali::DaliException e) {
40761       {
40762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40763       };
40764     } catch (...) {
40765       {
40766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40767       };
40768     }
40769   }
40770
40771   jresult = (void *)result;
40772   return jresult;
40773 }
40774
40775
40776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40777   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40778   unsigned int arg2 ;
40779
40780   arg1 = (Dali::PanGestureDetector *)jarg1;
40781   arg2 = (unsigned int)jarg2;
40782   {
40783     try {
40784       (arg1)->SetMinimumTouchesRequired(arg2);
40785     } catch (std::out_of_range& e) {
40786       {
40787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40788       };
40789     } catch (std::exception& e) {
40790       {
40791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40792       };
40793     } catch (Dali::DaliException e) {
40794       {
40795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40796       };
40797     } catch (...) {
40798       {
40799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40800       };
40801     }
40802   }
40803
40804 }
40805
40806
40807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40808   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40809   unsigned int arg2 ;
40810
40811   arg1 = (Dali::PanGestureDetector *)jarg1;
40812   arg2 = (unsigned int)jarg2;
40813   {
40814     try {
40815       (arg1)->SetMaximumTouchesRequired(arg2);
40816     } catch (std::out_of_range& e) {
40817       {
40818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40819       };
40820     } catch (std::exception& e) {
40821       {
40822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40823       };
40824     } catch (Dali::DaliException e) {
40825       {
40826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40827       };
40828     } catch (...) {
40829       {
40830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40831       };
40832     }
40833   }
40834
40835 }
40836
40837
40838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40839   unsigned int jresult ;
40840   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40841   unsigned int result;
40842
40843   arg1 = (Dali::PanGestureDetector *)jarg1;
40844   {
40845     try {
40846       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40847     } catch (std::out_of_range& e) {
40848       {
40849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40850       };
40851     } catch (std::exception& e) {
40852       {
40853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40854       };
40855     } catch (Dali::DaliException e) {
40856       {
40857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40858       };
40859     } catch (...) {
40860       {
40861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40862       };
40863     }
40864   }
40865
40866   jresult = result;
40867   return jresult;
40868 }
40869
40870
40871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40872   unsigned int jresult ;
40873   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40874   unsigned int result;
40875
40876   arg1 = (Dali::PanGestureDetector *)jarg1;
40877   {
40878     try {
40879       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40880     } catch (std::out_of_range& e) {
40881       {
40882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40883       };
40884     } catch (std::exception& e) {
40885       {
40886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40887       };
40888     } catch (Dali::DaliException e) {
40889       {
40890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40891       };
40892     } catch (...) {
40893       {
40894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40895       };
40896     }
40897   }
40898
40899   jresult = result;
40900   return jresult;
40901 }
40902
40903
40904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40905   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40906   Dali::Radian arg2 ;
40907   Dali::Radian arg3 ;
40908   Dali::Radian *argp2 ;
40909   Dali::Radian *argp3 ;
40910
40911   arg1 = (Dali::PanGestureDetector *)jarg1;
40912   argp2 = (Dali::Radian *)jarg2;
40913   if (!argp2) {
40914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40915     return ;
40916   }
40917   arg2 = *argp2;
40918   argp3 = (Dali::Radian *)jarg3;
40919   if (!argp3) {
40920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40921     return ;
40922   }
40923   arg3 = *argp3;
40924   {
40925     try {
40926       (arg1)->AddAngle(arg2,arg3);
40927     } catch (std::out_of_range& e) {
40928       {
40929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40930       };
40931     } catch (std::exception& e) {
40932       {
40933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40934       };
40935     } catch (Dali::DaliException e) {
40936       {
40937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40938       };
40939     } catch (...) {
40940       {
40941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40942       };
40943     }
40944   }
40945
40946 }
40947
40948
40949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40950   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40951   Dali::Radian arg2 ;
40952   Dali::Radian *argp2 ;
40953
40954   arg1 = (Dali::PanGestureDetector *)jarg1;
40955   argp2 = (Dali::Radian *)jarg2;
40956   if (!argp2) {
40957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40958     return ;
40959   }
40960   arg2 = *argp2;
40961   {
40962     try {
40963       (arg1)->AddAngle(arg2);
40964     } catch (std::out_of_range& e) {
40965       {
40966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40967       };
40968     } catch (std::exception& e) {
40969       {
40970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40971       };
40972     } catch (Dali::DaliException e) {
40973       {
40974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40975       };
40976     } catch (...) {
40977       {
40978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40979       };
40980     }
40981   }
40982
40983 }
40984
40985
40986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40987   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40988   Dali::Radian arg2 ;
40989   Dali::Radian arg3 ;
40990   Dali::Radian *argp2 ;
40991   Dali::Radian *argp3 ;
40992
40993   arg1 = (Dali::PanGestureDetector *)jarg1;
40994   argp2 = (Dali::Radian *)jarg2;
40995   if (!argp2) {
40996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40997     return ;
40998   }
40999   arg2 = *argp2;
41000   argp3 = (Dali::Radian *)jarg3;
41001   if (!argp3) {
41002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41003     return ;
41004   }
41005   arg3 = *argp3;
41006   {
41007     try {
41008       (arg1)->AddDirection(arg2,arg3);
41009     } catch (std::out_of_range& e) {
41010       {
41011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41012       };
41013     } catch (std::exception& e) {
41014       {
41015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41016       };
41017     } catch (Dali::DaliException e) {
41018       {
41019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41020       };
41021     } catch (...) {
41022       {
41023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41024       };
41025     }
41026   }
41027
41028 }
41029
41030
41031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41032   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41033   Dali::Radian arg2 ;
41034   Dali::Radian *argp2 ;
41035
41036   arg1 = (Dali::PanGestureDetector *)jarg1;
41037   argp2 = (Dali::Radian *)jarg2;
41038   if (!argp2) {
41039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41040     return ;
41041   }
41042   arg2 = *argp2;
41043   {
41044     try {
41045       (arg1)->AddDirection(arg2);
41046     } catch (std::out_of_range& e) {
41047       {
41048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41049       };
41050     } catch (std::exception& e) {
41051       {
41052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41053       };
41054     } catch (Dali::DaliException e) {
41055       {
41056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41057       };
41058     } catch (...) {
41059       {
41060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41061       };
41062     }
41063   }
41064
41065 }
41066
41067
41068 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41069   unsigned long jresult ;
41070   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41071   size_t result;
41072
41073   arg1 = (Dali::PanGestureDetector *)jarg1;
41074   {
41075     try {
41076       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41077     } catch (std::out_of_range& e) {
41078       {
41079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41080       };
41081     } catch (std::exception& e) {
41082       {
41083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41084       };
41085     } catch (Dali::DaliException e) {
41086       {
41087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41088       };
41089     } catch (...) {
41090       {
41091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41092       };
41093     }
41094   }
41095
41096   jresult = (unsigned long)result;
41097   return jresult;
41098 }
41099
41100
41101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41102   void * jresult ;
41103   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41104   size_t arg2 ;
41105   Dali::PanGestureDetector::AngleThresholdPair result;
41106
41107   arg1 = (Dali::PanGestureDetector *)jarg1;
41108   arg2 = (size_t)jarg2;
41109   {
41110     try {
41111       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41112     } catch (std::out_of_range& e) {
41113       {
41114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41115       };
41116     } catch (std::exception& e) {
41117       {
41118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41119       };
41120     } catch (Dali::DaliException e) {
41121       {
41122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41123       };
41124     } catch (...) {
41125       {
41126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41127       };
41128     }
41129   }
41130
41131   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41132   return jresult;
41133 }
41134
41135
41136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41137   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41138
41139   arg1 = (Dali::PanGestureDetector *)jarg1;
41140   {
41141     try {
41142       (arg1)->ClearAngles();
41143     } catch (std::out_of_range& e) {
41144       {
41145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41146       };
41147     } catch (std::exception& e) {
41148       {
41149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41150       };
41151     } catch (Dali::DaliException e) {
41152       {
41153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41154       };
41155     } catch (...) {
41156       {
41157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41158       };
41159     }
41160   }
41161
41162 }
41163
41164
41165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41166   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41167   Dali::Radian arg2 ;
41168   Dali::Radian *argp2 ;
41169
41170   arg1 = (Dali::PanGestureDetector *)jarg1;
41171   argp2 = (Dali::Radian *)jarg2;
41172   if (!argp2) {
41173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41174     return ;
41175   }
41176   arg2 = *argp2;
41177   {
41178     try {
41179       (arg1)->RemoveAngle(arg2);
41180     } catch (std::out_of_range& e) {
41181       {
41182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41183       };
41184     } catch (std::exception& e) {
41185       {
41186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41187       };
41188     } catch (Dali::DaliException e) {
41189       {
41190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41191       };
41192     } catch (...) {
41193       {
41194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41195       };
41196     }
41197   }
41198
41199 }
41200
41201
41202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41203   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41204   Dali::Radian arg2 ;
41205   Dali::Radian *argp2 ;
41206
41207   arg1 = (Dali::PanGestureDetector *)jarg1;
41208   argp2 = (Dali::Radian *)jarg2;
41209   if (!argp2) {
41210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41211     return ;
41212   }
41213   arg2 = *argp2;
41214   {
41215     try {
41216       (arg1)->RemoveDirection(arg2);
41217     } catch (std::out_of_range& e) {
41218       {
41219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41220       };
41221     } catch (std::exception& e) {
41222       {
41223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41224       };
41225     } catch (Dali::DaliException e) {
41226       {
41227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41228       };
41229     } catch (...) {
41230       {
41231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41232       };
41233     }
41234   }
41235
41236 }
41237
41238
41239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41240   void * jresult ;
41241   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41242   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41243
41244   arg1 = (Dali::PanGestureDetector *)jarg1;
41245   {
41246     try {
41247       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41248     } catch (std::out_of_range& e) {
41249       {
41250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41251       };
41252     } catch (std::exception& e) {
41253       {
41254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41255       };
41256     } catch (Dali::DaliException e) {
41257       {
41258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41259       };
41260     } catch (...) {
41261       {
41262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41263       };
41264     }
41265   }
41266
41267   jresult = (void *)result;
41268   return jresult;
41269 }
41270
41271
41272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41273   Dali::PanGesture *arg1 = 0 ;
41274
41275   arg1 = (Dali::PanGesture *)jarg1;
41276   if (!arg1) {
41277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41278     return ;
41279   }
41280   {
41281     try {
41282       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41283     } catch (std::out_of_range& e) {
41284       {
41285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41286       };
41287     } catch (std::exception& e) {
41288       {
41289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41290       };
41291     } catch (Dali::DaliException e) {
41292       {
41293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41294       };
41295     } catch (...) {
41296       {
41297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41298       };
41299     }
41300   }
41301
41302 }
41303
41304
41305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41306   void * jresult ;
41307   Dali::PanGesture *result = 0 ;
41308
41309   {
41310     try {
41311       result = (Dali::PanGesture *)new Dali::PanGesture();
41312     } catch (std::out_of_range& e) {
41313       {
41314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41315       };
41316     } catch (std::exception& e) {
41317       {
41318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41319       };
41320     } catch (Dali::DaliException e) {
41321       {
41322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41323       };
41324     } catch (...) {
41325       {
41326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41327       };
41328     }
41329   }
41330
41331   jresult = (void *)result;
41332   return jresult;
41333 }
41334
41335
41336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41337   void * jresult ;
41338   Dali::Gesture::State arg1 ;
41339   Dali::PanGesture *result = 0 ;
41340
41341   arg1 = (Dali::Gesture::State)jarg1;
41342   {
41343     try {
41344       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41345     } catch (std::out_of_range& e) {
41346       {
41347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41348       };
41349     } catch (std::exception& e) {
41350       {
41351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41352       };
41353     } catch (Dali::DaliException e) {
41354       {
41355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41356       };
41357     } catch (...) {
41358       {
41359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41360       };
41361     }
41362   }
41363
41364   jresult = (void *)result;
41365   return jresult;
41366 }
41367
41368
41369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41370   void * jresult ;
41371   Dali::PanGesture *arg1 = 0 ;
41372   Dali::PanGesture *result = 0 ;
41373
41374   arg1 = (Dali::PanGesture *)jarg1;
41375   if (!arg1) {
41376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41377     return 0;
41378   }
41379   {
41380     try {
41381       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41382     } catch (std::out_of_range& e) {
41383       {
41384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41385       };
41386     } catch (std::exception& e) {
41387       {
41388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41389       };
41390     } catch (Dali::DaliException e) {
41391       {
41392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41393       };
41394     } catch (...) {
41395       {
41396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41397       };
41398     }
41399   }
41400
41401   jresult = (void *)result;
41402   return jresult;
41403 }
41404
41405
41406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41407   void * jresult ;
41408   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41409   Dali::PanGesture *arg2 = 0 ;
41410   Dali::PanGesture *result = 0 ;
41411
41412   arg1 = (Dali::PanGesture *)jarg1;
41413   arg2 = (Dali::PanGesture *)jarg2;
41414   if (!arg2) {
41415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41416     return 0;
41417   }
41418   {
41419     try {
41420       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41421     } catch (std::out_of_range& e) {
41422       {
41423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41424       };
41425     } catch (std::exception& e) {
41426       {
41427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41428       };
41429     } catch (Dali::DaliException e) {
41430       {
41431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41432       };
41433     } catch (...) {
41434       {
41435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41436       };
41437     }
41438   }
41439
41440   jresult = (void *)result;
41441   return jresult;
41442 }
41443
41444
41445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41446   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41447
41448   arg1 = (Dali::PanGesture *)jarg1;
41449   {
41450     try {
41451       delete arg1;
41452     } catch (std::out_of_range& e) {
41453       {
41454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41455       };
41456     } catch (std::exception& e) {
41457       {
41458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41459       };
41460     } catch (Dali::DaliException e) {
41461       {
41462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41463       };
41464     } catch (...) {
41465       {
41466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41467       };
41468     }
41469   }
41470
41471 }
41472
41473
41474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41475   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41476   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41477
41478   arg1 = (Dali::PanGesture *)jarg1;
41479   arg2 = (Dali::Vector2 *)jarg2;
41480   if (arg1) (arg1)->velocity = *arg2;
41481 }
41482
41483
41484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41485   void * jresult ;
41486   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41487   Dali::Vector2 *result = 0 ;
41488
41489   arg1 = (Dali::PanGesture *)jarg1;
41490   result = (Dali::Vector2 *)& ((arg1)->velocity);
41491   jresult = (void *)result;
41492   return jresult;
41493 }
41494
41495
41496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41497   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41498   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41499
41500   arg1 = (Dali::PanGesture *)jarg1;
41501   arg2 = (Dali::Vector2 *)jarg2;
41502   if (arg1) (arg1)->displacement = *arg2;
41503 }
41504
41505
41506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41507   void * jresult ;
41508   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41509   Dali::Vector2 *result = 0 ;
41510
41511   arg1 = (Dali::PanGesture *)jarg1;
41512   result = (Dali::Vector2 *)& ((arg1)->displacement);
41513   jresult = (void *)result;
41514   return jresult;
41515 }
41516
41517
41518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41519   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41520   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41521
41522   arg1 = (Dali::PanGesture *)jarg1;
41523   arg2 = (Dali::Vector2 *)jarg2;
41524   if (arg1) (arg1)->position = *arg2;
41525 }
41526
41527
41528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41529   void * jresult ;
41530   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41531   Dali::Vector2 *result = 0 ;
41532
41533   arg1 = (Dali::PanGesture *)jarg1;
41534   result = (Dali::Vector2 *)& ((arg1)->position);
41535   jresult = (void *)result;
41536   return jresult;
41537 }
41538
41539
41540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41541   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41542   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41543
41544   arg1 = (Dali::PanGesture *)jarg1;
41545   arg2 = (Dali::Vector2 *)jarg2;
41546   if (arg1) (arg1)->screenVelocity = *arg2;
41547 }
41548
41549
41550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41551   void * jresult ;
41552   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41553   Dali::Vector2 *result = 0 ;
41554
41555   arg1 = (Dali::PanGesture *)jarg1;
41556   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41557   jresult = (void *)result;
41558   return jresult;
41559 }
41560
41561
41562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41563   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41564   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41565
41566   arg1 = (Dali::PanGesture *)jarg1;
41567   arg2 = (Dali::Vector2 *)jarg2;
41568   if (arg1) (arg1)->screenDisplacement = *arg2;
41569 }
41570
41571
41572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41573   void * jresult ;
41574   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41575   Dali::Vector2 *result = 0 ;
41576
41577   arg1 = (Dali::PanGesture *)jarg1;
41578   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41579   jresult = (void *)result;
41580   return jresult;
41581 }
41582
41583
41584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41585   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41586   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41587
41588   arg1 = (Dali::PanGesture *)jarg1;
41589   arg2 = (Dali::Vector2 *)jarg2;
41590   if (arg1) (arg1)->screenPosition = *arg2;
41591 }
41592
41593
41594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41595   void * jresult ;
41596   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41597   Dali::Vector2 *result = 0 ;
41598
41599   arg1 = (Dali::PanGesture *)jarg1;
41600   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41601   jresult = (void *)result;
41602   return jresult;
41603 }
41604
41605
41606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41607   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41608   unsigned int arg2 ;
41609
41610   arg1 = (Dali::PanGesture *)jarg1;
41611   arg2 = (unsigned int)jarg2;
41612   if (arg1) (arg1)->numberOfTouches = arg2;
41613 }
41614
41615
41616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41617   unsigned int jresult ;
41618   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41619   unsigned int result;
41620
41621   arg1 = (Dali::PanGesture *)jarg1;
41622   result = (unsigned int) ((arg1)->numberOfTouches);
41623   jresult = result;
41624   return jresult;
41625 }
41626
41627
41628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41629   float jresult ;
41630   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41631   float result;
41632
41633   arg1 = (Dali::PanGesture *)jarg1;
41634   {
41635     try {
41636       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41637     } catch (std::out_of_range& e) {
41638       {
41639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41640       };
41641     } catch (std::exception& e) {
41642       {
41643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41644       };
41645     } catch (Dali::DaliException e) {
41646       {
41647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41648       };
41649     } catch (...) {
41650       {
41651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41652       };
41653     }
41654   }
41655
41656   jresult = result;
41657   return jresult;
41658 }
41659
41660
41661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41662   float jresult ;
41663   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41664   float result;
41665
41666   arg1 = (Dali::PanGesture *)jarg1;
41667   {
41668     try {
41669       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41670     } catch (std::out_of_range& e) {
41671       {
41672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41673       };
41674     } catch (std::exception& e) {
41675       {
41676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41677       };
41678     } catch (Dali::DaliException e) {
41679       {
41680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41681       };
41682     } catch (...) {
41683       {
41684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41685       };
41686     }
41687   }
41688
41689   jresult = result;
41690   return jresult;
41691 }
41692
41693
41694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41695   float jresult ;
41696   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41697   float result;
41698
41699   arg1 = (Dali::PanGesture *)jarg1;
41700   {
41701     try {
41702       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41703     } catch (std::out_of_range& e) {
41704       {
41705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41706       };
41707     } catch (std::exception& e) {
41708       {
41709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41710       };
41711     } catch (Dali::DaliException e) {
41712       {
41713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41714       };
41715     } catch (...) {
41716       {
41717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41718       };
41719     }
41720   }
41721
41722   jresult = result;
41723   return jresult;
41724 }
41725
41726
41727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41728   float jresult ;
41729   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41730   float result;
41731
41732   arg1 = (Dali::PanGesture *)jarg1;
41733   {
41734     try {
41735       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41736     } catch (std::out_of_range& e) {
41737       {
41738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41739       };
41740     } catch (std::exception& e) {
41741       {
41742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41743       };
41744     } catch (Dali::DaliException e) {
41745       {
41746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41747       };
41748     } catch (...) {
41749       {
41750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41751       };
41752     }
41753   }
41754
41755   jresult = result;
41756   return jresult;
41757 }
41758
41759
41760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41761   void * jresult ;
41762   Dali::PinchGestureDetector *result = 0 ;
41763
41764   {
41765     try {
41766       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41767     } catch (std::out_of_range& e) {
41768       {
41769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41770       };
41771     } catch (std::exception& e) {
41772       {
41773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41774       };
41775     } catch (Dali::DaliException e) {
41776       {
41777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41778       };
41779     } catch (...) {
41780       {
41781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41782       };
41783     }
41784   }
41785
41786   jresult = (void *)result;
41787   return jresult;
41788 }
41789
41790
41791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41792   void * jresult ;
41793   Dali::PinchGestureDetector result;
41794
41795   {
41796     try {
41797       result = Dali::PinchGestureDetector::New();
41798     } catch (std::out_of_range& e) {
41799       {
41800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41801       };
41802     } catch (std::exception& e) {
41803       {
41804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41805       };
41806     } catch (Dali::DaliException e) {
41807       {
41808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41809       };
41810     } catch (...) {
41811       {
41812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41813       };
41814     }
41815   }
41816
41817   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41818   return jresult;
41819 }
41820
41821
41822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41823   void * jresult ;
41824   Dali::BaseHandle arg1 ;
41825   Dali::BaseHandle *argp1 ;
41826   Dali::PinchGestureDetector result;
41827
41828   argp1 = (Dali::BaseHandle *)jarg1;
41829   if (!argp1) {
41830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41831     return 0;
41832   }
41833   arg1 = *argp1;
41834   {
41835     try {
41836       result = Dali::PinchGestureDetector::DownCast(arg1);
41837     } catch (std::out_of_range& e) {
41838       {
41839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41840       };
41841     } catch (std::exception& e) {
41842       {
41843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41844       };
41845     } catch (Dali::DaliException e) {
41846       {
41847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41848       };
41849     } catch (...) {
41850       {
41851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41852       };
41853     }
41854   }
41855
41856   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41857   return jresult;
41858 }
41859
41860
41861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41862   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41863
41864   arg1 = (Dali::PinchGestureDetector *)jarg1;
41865   {
41866     try {
41867       delete arg1;
41868     } catch (std::out_of_range& e) {
41869       {
41870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41871       };
41872     } catch (std::exception& e) {
41873       {
41874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41875       };
41876     } catch (Dali::DaliException e) {
41877       {
41878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41879       };
41880     } catch (...) {
41881       {
41882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41883       };
41884     }
41885   }
41886
41887 }
41888
41889
41890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41891   void * jresult ;
41892   Dali::PinchGestureDetector *arg1 = 0 ;
41893   Dali::PinchGestureDetector *result = 0 ;
41894
41895   arg1 = (Dali::PinchGestureDetector *)jarg1;
41896   if (!arg1) {
41897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41898     return 0;
41899   }
41900   {
41901     try {
41902       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41903     } catch (std::out_of_range& e) {
41904       {
41905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41906       };
41907     } catch (std::exception& e) {
41908       {
41909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41910       };
41911     } catch (Dali::DaliException e) {
41912       {
41913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41914       };
41915     } catch (...) {
41916       {
41917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41918       };
41919     }
41920   }
41921
41922   jresult = (void *)result;
41923   return jresult;
41924 }
41925
41926
41927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41928   void * jresult ;
41929   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41930   Dali::PinchGestureDetector *arg2 = 0 ;
41931   Dali::PinchGestureDetector *result = 0 ;
41932
41933   arg1 = (Dali::PinchGestureDetector *)jarg1;
41934   arg2 = (Dali::PinchGestureDetector *)jarg2;
41935   if (!arg2) {
41936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41937     return 0;
41938   }
41939   {
41940     try {
41941       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41942     } catch (std::out_of_range& e) {
41943       {
41944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41945       };
41946     } catch (std::exception& e) {
41947       {
41948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41949       };
41950     } catch (Dali::DaliException e) {
41951       {
41952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41953       };
41954     } catch (...) {
41955       {
41956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41957       };
41958     }
41959   }
41960
41961   jresult = (void *)result;
41962   return jresult;
41963 }
41964
41965
41966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41967   void * jresult ;
41968   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41969   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41970
41971   arg1 = (Dali::PinchGestureDetector *)jarg1;
41972   {
41973     try {
41974       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41975     } catch (std::out_of_range& e) {
41976       {
41977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41978       };
41979     } catch (std::exception& e) {
41980       {
41981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41982       };
41983     } catch (Dali::DaliException e) {
41984       {
41985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41986       };
41987     } catch (...) {
41988       {
41989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41990       };
41991     }
41992   }
41993
41994   jresult = (void *)result;
41995   return jresult;
41996 }
41997
41998
41999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42000   void * jresult ;
42001   Dali::Gesture::State arg1 ;
42002   Dali::PinchGesture *result = 0 ;
42003
42004   arg1 = (Dali::Gesture::State)jarg1;
42005   {
42006     try {
42007       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42008     } catch (std::out_of_range& e) {
42009       {
42010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42011       };
42012     } catch (std::exception& e) {
42013       {
42014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42015       };
42016     } catch (Dali::DaliException e) {
42017       {
42018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42019       };
42020     } catch (...) {
42021       {
42022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42023       };
42024     }
42025   }
42026
42027   jresult = (void *)result;
42028   return jresult;
42029 }
42030
42031
42032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42033   void * jresult ;
42034   Dali::PinchGesture *arg1 = 0 ;
42035   Dali::PinchGesture *result = 0 ;
42036
42037   arg1 = (Dali::PinchGesture *)jarg1;
42038   if (!arg1) {
42039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42040     return 0;
42041   }
42042   {
42043     try {
42044       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42045     } catch (std::out_of_range& e) {
42046       {
42047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42048       };
42049     } catch (std::exception& e) {
42050       {
42051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42052       };
42053     } catch (Dali::DaliException e) {
42054       {
42055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42056       };
42057     } catch (...) {
42058       {
42059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42060       };
42061     }
42062   }
42063
42064   jresult = (void *)result;
42065   return jresult;
42066 }
42067
42068
42069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42070   void * jresult ;
42071   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42072   Dali::PinchGesture *arg2 = 0 ;
42073   Dali::PinchGesture *result = 0 ;
42074
42075   arg1 = (Dali::PinchGesture *)jarg1;
42076   arg2 = (Dali::PinchGesture *)jarg2;
42077   if (!arg2) {
42078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42079     return 0;
42080   }
42081   {
42082     try {
42083       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42084     } catch (std::out_of_range& e) {
42085       {
42086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42087       };
42088     } catch (std::exception& e) {
42089       {
42090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42091       };
42092     } catch (Dali::DaliException e) {
42093       {
42094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42095       };
42096     } catch (...) {
42097       {
42098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42099       };
42100     }
42101   }
42102
42103   jresult = (void *)result;
42104   return jresult;
42105 }
42106
42107
42108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42109   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42110
42111   arg1 = (Dali::PinchGesture *)jarg1;
42112   {
42113     try {
42114       delete arg1;
42115     } catch (std::out_of_range& e) {
42116       {
42117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42118       };
42119     } catch (std::exception& e) {
42120       {
42121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42122       };
42123     } catch (Dali::DaliException e) {
42124       {
42125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42126       };
42127     } catch (...) {
42128       {
42129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42130       };
42131     }
42132   }
42133
42134 }
42135
42136
42137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42138   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42139   float arg2 ;
42140
42141   arg1 = (Dali::PinchGesture *)jarg1;
42142   arg2 = (float)jarg2;
42143   if (arg1) (arg1)->scale = arg2;
42144 }
42145
42146
42147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42148   float jresult ;
42149   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42150   float result;
42151
42152   arg1 = (Dali::PinchGesture *)jarg1;
42153   result = (float) ((arg1)->scale);
42154   jresult = result;
42155   return jresult;
42156 }
42157
42158
42159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42160   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42161   float arg2 ;
42162
42163   arg1 = (Dali::PinchGesture *)jarg1;
42164   arg2 = (float)jarg2;
42165   if (arg1) (arg1)->speed = arg2;
42166 }
42167
42168
42169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42170   float jresult ;
42171   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42172   float result;
42173
42174   arg1 = (Dali::PinchGesture *)jarg1;
42175   result = (float) ((arg1)->speed);
42176   jresult = result;
42177   return jresult;
42178 }
42179
42180
42181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42182   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42183   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42184
42185   arg1 = (Dali::PinchGesture *)jarg1;
42186   arg2 = (Dali::Vector2 *)jarg2;
42187   if (arg1) (arg1)->screenCenterPoint = *arg2;
42188 }
42189
42190
42191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42192   void * jresult ;
42193   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42194   Dali::Vector2 *result = 0 ;
42195
42196   arg1 = (Dali::PinchGesture *)jarg1;
42197   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42198   jresult = (void *)result;
42199   return jresult;
42200 }
42201
42202
42203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42204   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42205   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42206
42207   arg1 = (Dali::PinchGesture *)jarg1;
42208   arg2 = (Dali::Vector2 *)jarg2;
42209   if (arg1) (arg1)->localCenterPoint = *arg2;
42210 }
42211
42212
42213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42214   void * jresult ;
42215   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42216   Dali::Vector2 *result = 0 ;
42217
42218   arg1 = (Dali::PinchGesture *)jarg1;
42219   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42220   jresult = (void *)result;
42221   return jresult;
42222 }
42223
42224
42225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42226   void * jresult ;
42227   Dali::TapGestureDetector *result = 0 ;
42228
42229   {
42230     try {
42231       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42232     } catch (std::out_of_range& e) {
42233       {
42234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42235       };
42236     } catch (std::exception& e) {
42237       {
42238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42239       };
42240     } catch (Dali::DaliException e) {
42241       {
42242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42243       };
42244     } catch (...) {
42245       {
42246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42247       };
42248     }
42249   }
42250
42251   jresult = (void *)result;
42252   return jresult;
42253 }
42254
42255
42256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42257   void * jresult ;
42258   Dali::TapGestureDetector result;
42259
42260   {
42261     try {
42262       result = Dali::TapGestureDetector::New();
42263     } catch (std::out_of_range& e) {
42264       {
42265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42266       };
42267     } catch (std::exception& e) {
42268       {
42269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42270       };
42271     } catch (Dali::DaliException e) {
42272       {
42273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42274       };
42275     } catch (...) {
42276       {
42277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42278       };
42279     }
42280   }
42281
42282   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42283   return jresult;
42284 }
42285
42286
42287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42288   void * jresult ;
42289   unsigned int arg1 ;
42290   Dali::TapGestureDetector result;
42291
42292   arg1 = (unsigned int)jarg1;
42293   {
42294     try {
42295       result = Dali::TapGestureDetector::New(arg1);
42296     } catch (std::out_of_range& e) {
42297       {
42298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42299       };
42300     } catch (std::exception& e) {
42301       {
42302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42303       };
42304     } catch (Dali::DaliException e) {
42305       {
42306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42307       };
42308     } catch (...) {
42309       {
42310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42311       };
42312     }
42313   }
42314
42315   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42316   return jresult;
42317 }
42318
42319
42320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42321   void * jresult ;
42322   Dali::BaseHandle arg1 ;
42323   Dali::BaseHandle *argp1 ;
42324   Dali::TapGestureDetector result;
42325
42326   argp1 = (Dali::BaseHandle *)jarg1;
42327   if (!argp1) {
42328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42329     return 0;
42330   }
42331   arg1 = *argp1;
42332   {
42333     try {
42334       result = Dali::TapGestureDetector::DownCast(arg1);
42335     } catch (std::out_of_range& e) {
42336       {
42337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42338       };
42339     } catch (std::exception& e) {
42340       {
42341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42342       };
42343     } catch (Dali::DaliException e) {
42344       {
42345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42346       };
42347     } catch (...) {
42348       {
42349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42350       };
42351     }
42352   }
42353
42354   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42355   return jresult;
42356 }
42357
42358
42359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42360   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42361
42362   arg1 = (Dali::TapGestureDetector *)jarg1;
42363   {
42364     try {
42365       delete arg1;
42366     } catch (std::out_of_range& e) {
42367       {
42368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42369       };
42370     } catch (std::exception& e) {
42371       {
42372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42373       };
42374     } catch (Dali::DaliException e) {
42375       {
42376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42377       };
42378     } catch (...) {
42379       {
42380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42381       };
42382     }
42383   }
42384
42385 }
42386
42387
42388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42389   void * jresult ;
42390   Dali::TapGestureDetector *arg1 = 0 ;
42391   Dali::TapGestureDetector *result = 0 ;
42392
42393   arg1 = (Dali::TapGestureDetector *)jarg1;
42394   if (!arg1) {
42395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42396     return 0;
42397   }
42398   {
42399     try {
42400       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42401     } catch (std::out_of_range& e) {
42402       {
42403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42404       };
42405     } catch (std::exception& e) {
42406       {
42407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42408       };
42409     } catch (Dali::DaliException e) {
42410       {
42411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42412       };
42413     } catch (...) {
42414       {
42415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42416       };
42417     }
42418   }
42419
42420   jresult = (void *)result;
42421   return jresult;
42422 }
42423
42424
42425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42426   void * jresult ;
42427   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42428   Dali::TapGestureDetector *arg2 = 0 ;
42429   Dali::TapGestureDetector *result = 0 ;
42430
42431   arg1 = (Dali::TapGestureDetector *)jarg1;
42432   arg2 = (Dali::TapGestureDetector *)jarg2;
42433   if (!arg2) {
42434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42435     return 0;
42436   }
42437   {
42438     try {
42439       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42440     } catch (std::out_of_range& e) {
42441       {
42442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42443       };
42444     } catch (std::exception& e) {
42445       {
42446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42447       };
42448     } catch (Dali::DaliException e) {
42449       {
42450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42451       };
42452     } catch (...) {
42453       {
42454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42455       };
42456     }
42457   }
42458
42459   jresult = (void *)result;
42460   return jresult;
42461 }
42462
42463
42464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42465   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42466   unsigned int arg2 ;
42467
42468   arg1 = (Dali::TapGestureDetector *)jarg1;
42469   arg2 = (unsigned int)jarg2;
42470   {
42471     try {
42472       (arg1)->SetMinimumTapsRequired(arg2);
42473     } catch (std::out_of_range& e) {
42474       {
42475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42476       };
42477     } catch (std::exception& e) {
42478       {
42479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42480       };
42481     } catch (Dali::DaliException e) {
42482       {
42483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42484       };
42485     } catch (...) {
42486       {
42487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42488       };
42489     }
42490   }
42491
42492 }
42493
42494
42495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42496   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42497   unsigned int arg2 ;
42498
42499   arg1 = (Dali::TapGestureDetector *)jarg1;
42500   arg2 = (unsigned int)jarg2;
42501   {
42502     try {
42503       (arg1)->SetMaximumTapsRequired(arg2);
42504     } catch (std::out_of_range& e) {
42505       {
42506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42507       };
42508     } catch (std::exception& e) {
42509       {
42510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42511       };
42512     } catch (Dali::DaliException e) {
42513       {
42514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42515       };
42516     } catch (...) {
42517       {
42518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42519       };
42520     }
42521   }
42522
42523 }
42524
42525
42526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42527   unsigned int jresult ;
42528   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42529   unsigned int result;
42530
42531   arg1 = (Dali::TapGestureDetector *)jarg1;
42532   {
42533     try {
42534       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42535     } catch (std::out_of_range& e) {
42536       {
42537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42538       };
42539     } catch (std::exception& e) {
42540       {
42541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42542       };
42543     } catch (Dali::DaliException e) {
42544       {
42545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42546       };
42547     } catch (...) {
42548       {
42549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42550       };
42551     }
42552   }
42553
42554   jresult = result;
42555   return jresult;
42556 }
42557
42558
42559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42560   unsigned int jresult ;
42561   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42562   unsigned int result;
42563
42564   arg1 = (Dali::TapGestureDetector *)jarg1;
42565   {
42566     try {
42567       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42568     } catch (std::out_of_range& e) {
42569       {
42570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42571       };
42572     } catch (std::exception& e) {
42573       {
42574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42575       };
42576     } catch (Dali::DaliException e) {
42577       {
42578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42579       };
42580     } catch (...) {
42581       {
42582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42583       };
42584     }
42585   }
42586
42587   jresult = result;
42588   return jresult;
42589 }
42590
42591
42592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42593   void * jresult ;
42594   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42595   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42596
42597   arg1 = (Dali::TapGestureDetector *)jarg1;
42598   {
42599     try {
42600       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42601     } catch (std::out_of_range& e) {
42602       {
42603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42604       };
42605     } catch (std::exception& e) {
42606       {
42607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42608       };
42609     } catch (Dali::DaliException e) {
42610       {
42611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42612       };
42613     } catch (...) {
42614       {
42615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42616       };
42617     }
42618   }
42619
42620   jresult = (void *)result;
42621   return jresult;
42622 }
42623
42624
42625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42626   void * jresult ;
42627   Dali::TapGesture *result = 0 ;
42628
42629   {
42630     try {
42631       result = (Dali::TapGesture *)new Dali::TapGesture();
42632     } catch (std::out_of_range& e) {
42633       {
42634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42635       };
42636     } catch (std::exception& e) {
42637       {
42638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42639       };
42640     } catch (Dali::DaliException e) {
42641       {
42642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42643       };
42644     } catch (...) {
42645       {
42646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42647       };
42648     }
42649   }
42650
42651   jresult = (void *)result;
42652   return jresult;
42653 }
42654
42655
42656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42657   void * jresult ;
42658   Dali::TapGesture *arg1 = 0 ;
42659   Dali::TapGesture *result = 0 ;
42660
42661   arg1 = (Dali::TapGesture *)jarg1;
42662   if (!arg1) {
42663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42664     return 0;
42665   }
42666   {
42667     try {
42668       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42669     } catch (std::out_of_range& e) {
42670       {
42671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42672       };
42673     } catch (std::exception& e) {
42674       {
42675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42676       };
42677     } catch (Dali::DaliException e) {
42678       {
42679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42680       };
42681     } catch (...) {
42682       {
42683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42684       };
42685     }
42686   }
42687
42688   jresult = (void *)result;
42689   return jresult;
42690 }
42691
42692
42693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42694   void * jresult ;
42695   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42696   Dali::TapGesture *arg2 = 0 ;
42697   Dali::TapGesture *result = 0 ;
42698
42699   arg1 = (Dali::TapGesture *)jarg1;
42700   arg2 = (Dali::TapGesture *)jarg2;
42701   if (!arg2) {
42702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42703     return 0;
42704   }
42705   {
42706     try {
42707       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42708     } catch (std::out_of_range& e) {
42709       {
42710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42711       };
42712     } catch (std::exception& e) {
42713       {
42714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42715       };
42716     } catch (Dali::DaliException e) {
42717       {
42718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42719       };
42720     } catch (...) {
42721       {
42722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42723       };
42724     }
42725   }
42726
42727   jresult = (void *)result;
42728   return jresult;
42729 }
42730
42731
42732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42733   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42734
42735   arg1 = (Dali::TapGesture *)jarg1;
42736   {
42737     try {
42738       delete arg1;
42739     } catch (std::out_of_range& e) {
42740       {
42741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42742       };
42743     } catch (std::exception& e) {
42744       {
42745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42746       };
42747     } catch (Dali::DaliException e) {
42748       {
42749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42750       };
42751     } catch (...) {
42752       {
42753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42754       };
42755     }
42756   }
42757
42758 }
42759
42760
42761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42762   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42763   unsigned int arg2 ;
42764
42765   arg1 = (Dali::TapGesture *)jarg1;
42766   arg2 = (unsigned int)jarg2;
42767   if (arg1) (arg1)->numberOfTaps = arg2;
42768 }
42769
42770
42771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42772   unsigned int jresult ;
42773   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42774   unsigned int result;
42775
42776   arg1 = (Dali::TapGesture *)jarg1;
42777   result = (unsigned int) ((arg1)->numberOfTaps);
42778   jresult = result;
42779   return jresult;
42780 }
42781
42782
42783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42784   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42785   unsigned int arg2 ;
42786
42787   arg1 = (Dali::TapGesture *)jarg1;
42788   arg2 = (unsigned int)jarg2;
42789   if (arg1) (arg1)->numberOfTouches = arg2;
42790 }
42791
42792
42793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42794   unsigned int jresult ;
42795   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42796   unsigned int result;
42797
42798   arg1 = (Dali::TapGesture *)jarg1;
42799   result = (unsigned int) ((arg1)->numberOfTouches);
42800   jresult = result;
42801   return jresult;
42802 }
42803
42804
42805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42806   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42807   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42808
42809   arg1 = (Dali::TapGesture *)jarg1;
42810   arg2 = (Dali::Vector2 *)jarg2;
42811   if (arg1) (arg1)->screenPoint = *arg2;
42812 }
42813
42814
42815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42816   void * jresult ;
42817   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42818   Dali::Vector2 *result = 0 ;
42819
42820   arg1 = (Dali::TapGesture *)jarg1;
42821   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42822   jresult = (void *)result;
42823   return jresult;
42824 }
42825
42826
42827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42828   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42829   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42830
42831   arg1 = (Dali::TapGesture *)jarg1;
42832   arg2 = (Dali::Vector2 *)jarg2;
42833   if (arg1) (arg1)->localPoint = *arg2;
42834 }
42835
42836
42837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42838   void * jresult ;
42839   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42840   Dali::Vector2 *result = 0 ;
42841
42842   arg1 = (Dali::TapGesture *)jarg1;
42843   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42844   jresult = (void *)result;
42845   return jresult;
42846 }
42847
42848
42849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42850   void * jresult ;
42851   Dali::AlphaFunction *result = 0 ;
42852
42853   {
42854     try {
42855       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42856     } catch (std::out_of_range& e) {
42857       {
42858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42859       };
42860     } catch (std::exception& e) {
42861       {
42862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42863       };
42864     } catch (Dali::DaliException e) {
42865       {
42866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42867       };
42868     } catch (...) {
42869       {
42870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42871       };
42872     }
42873   }
42874
42875   jresult = (void *)result;
42876   return jresult;
42877 }
42878
42879
42880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42881   void * jresult ;
42882   Dali::AlphaFunction::BuiltinFunction arg1 ;
42883   Dali::AlphaFunction *result = 0 ;
42884
42885   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42886   {
42887     try {
42888       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42889     } catch (std::out_of_range& e) {
42890       {
42891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42892       };
42893     } catch (std::exception& e) {
42894       {
42895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42896       };
42897     } catch (Dali::DaliException e) {
42898       {
42899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42900       };
42901     } catch (...) {
42902       {
42903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42904       };
42905     }
42906   }
42907
42908   jresult = (void *)result;
42909   return jresult;
42910 }
42911
42912
42913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42914   void * jresult ;
42915   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42916   Dali::AlphaFunction *result = 0 ;
42917
42918   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42919   {
42920     try {
42921       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42922     } catch (std::out_of_range& e) {
42923       {
42924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42925       };
42926     } catch (std::exception& e) {
42927       {
42928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42929       };
42930     } catch (Dali::DaliException e) {
42931       {
42932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42933       };
42934     } catch (...) {
42935       {
42936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42937       };
42938     }
42939   }
42940
42941   jresult = (void *)result;
42942   return jresult;
42943 }
42944
42945
42946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42947   void * jresult ;
42948   Dali::Vector2 *arg1 = 0 ;
42949   Dali::Vector2 *arg2 = 0 ;
42950   Dali::AlphaFunction *result = 0 ;
42951
42952   arg1 = (Dali::Vector2 *)jarg1;
42953   if (!arg1) {
42954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42955     return 0;
42956   }
42957   arg2 = (Dali::Vector2 *)jarg2;
42958   if (!arg2) {
42959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42960     return 0;
42961   }
42962   {
42963     try {
42964       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42965     } catch (std::out_of_range& e) {
42966       {
42967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42968       };
42969     } catch (std::exception& e) {
42970       {
42971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42972       };
42973     } catch (Dali::DaliException e) {
42974       {
42975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42976       };
42977     } catch (...) {
42978       {
42979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42980       };
42981     }
42982   }
42983
42984   jresult = (void *)result;
42985   return jresult;
42986 }
42987
42988
42989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42990   void * jresult ;
42991   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42992   Dali::Vector4 result;
42993
42994   arg1 = (Dali::AlphaFunction *)jarg1;
42995   {
42996     try {
42997       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42998     } catch (std::out_of_range& e) {
42999       {
43000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43001       };
43002     } catch (std::exception& e) {
43003       {
43004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43005       };
43006     } catch (Dali::DaliException e) {
43007       {
43008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43009       };
43010     } catch (...) {
43011       {
43012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43013       };
43014     }
43015   }
43016
43017   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43018   return jresult;
43019 }
43020
43021
43022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43023   void * jresult ;
43024   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43025   Dali::AlphaFunctionPrototype result;
43026
43027   arg1 = (Dali::AlphaFunction *)jarg1;
43028   {
43029     try {
43030       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43031     } catch (std::out_of_range& e) {
43032       {
43033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43034       };
43035     } catch (std::exception& e) {
43036       {
43037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43038       };
43039     } catch (Dali::DaliException e) {
43040       {
43041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43042       };
43043     } catch (...) {
43044       {
43045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43046       };
43047     }
43048   }
43049
43050   jresult = (void *)result;
43051   return jresult;
43052 }
43053
43054
43055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43056   int jresult ;
43057   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43058   Dali::AlphaFunction::BuiltinFunction result;
43059
43060   arg1 = (Dali::AlphaFunction *)jarg1;
43061   {
43062     try {
43063       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43064     } catch (std::out_of_range& e) {
43065       {
43066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43067       };
43068     } catch (std::exception& e) {
43069       {
43070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43071       };
43072     } catch (Dali::DaliException e) {
43073       {
43074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43075       };
43076     } catch (...) {
43077       {
43078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43079       };
43080     }
43081   }
43082
43083   jresult = (int)result;
43084   return jresult;
43085 }
43086
43087
43088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43089   int jresult ;
43090   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43091   Dali::AlphaFunction::Mode result;
43092
43093   arg1 = (Dali::AlphaFunction *)jarg1;
43094   {
43095     try {
43096       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43097     } catch (std::out_of_range& e) {
43098       {
43099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43100       };
43101     } catch (std::exception& e) {
43102       {
43103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43104       };
43105     } catch (Dali::DaliException e) {
43106       {
43107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43108       };
43109     } catch (...) {
43110       {
43111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43112       };
43113     }
43114   }
43115
43116   jresult = (int)result;
43117   return jresult;
43118 }
43119
43120
43121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43122   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43123
43124   arg1 = (Dali::AlphaFunction *)jarg1;
43125   {
43126     try {
43127       delete arg1;
43128     } catch (std::out_of_range& e) {
43129       {
43130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43131       };
43132     } catch (std::exception& e) {
43133       {
43134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43135       };
43136     } catch (Dali::DaliException e) {
43137       {
43138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43139       };
43140     } catch (...) {
43141       {
43142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43143       };
43144     }
43145   }
43146
43147 }
43148
43149
43150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43151   void * jresult ;
43152   Dali::KeyFrames result;
43153
43154   {
43155     try {
43156       result = Dali::KeyFrames::New();
43157     } catch (std::out_of_range& e) {
43158       {
43159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43160       };
43161     } catch (std::exception& e) {
43162       {
43163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43164       };
43165     } catch (Dali::DaliException e) {
43166       {
43167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43168       };
43169     } catch (...) {
43170       {
43171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43172       };
43173     }
43174   }
43175
43176   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43177   return jresult;
43178 }
43179
43180
43181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43182   void * jresult ;
43183   Dali::BaseHandle arg1 ;
43184   Dali::BaseHandle *argp1 ;
43185   Dali::KeyFrames result;
43186
43187   argp1 = (Dali::BaseHandle *)jarg1;
43188   if (!argp1) {
43189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43190     return 0;
43191   }
43192   arg1 = *argp1;
43193   {
43194     try {
43195       result = Dali::KeyFrames::DownCast(arg1);
43196     } catch (std::out_of_range& e) {
43197       {
43198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43199       };
43200     } catch (std::exception& e) {
43201       {
43202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43203       };
43204     } catch (Dali::DaliException e) {
43205       {
43206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43207       };
43208     } catch (...) {
43209       {
43210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43211       };
43212     }
43213   }
43214
43215   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43216   return jresult;
43217 }
43218
43219
43220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43221   void * jresult ;
43222   Dali::KeyFrames *result = 0 ;
43223
43224   {
43225     try {
43226       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43227     } catch (std::out_of_range& e) {
43228       {
43229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43230       };
43231     } catch (std::exception& e) {
43232       {
43233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43234       };
43235     } catch (Dali::DaliException e) {
43236       {
43237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43238       };
43239     } catch (...) {
43240       {
43241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43242       };
43243     }
43244   }
43245
43246   jresult = (void *)result;
43247   return jresult;
43248 }
43249
43250
43251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43252   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43253
43254   arg1 = (Dali::KeyFrames *)jarg1;
43255   {
43256     try {
43257       delete arg1;
43258     } catch (std::out_of_range& e) {
43259       {
43260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43261       };
43262     } catch (std::exception& e) {
43263       {
43264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43265       };
43266     } catch (Dali::DaliException e) {
43267       {
43268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43269       };
43270     } catch (...) {
43271       {
43272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43273       };
43274     }
43275   }
43276
43277 }
43278
43279
43280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43281   void * jresult ;
43282   Dali::KeyFrames *arg1 = 0 ;
43283   Dali::KeyFrames *result = 0 ;
43284
43285   arg1 = (Dali::KeyFrames *)jarg1;
43286   if (!arg1) {
43287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43288     return 0;
43289   }
43290   {
43291     try {
43292       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43293     } catch (std::out_of_range& e) {
43294       {
43295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43296       };
43297     } catch (std::exception& e) {
43298       {
43299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43300       };
43301     } catch (Dali::DaliException e) {
43302       {
43303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43304       };
43305     } catch (...) {
43306       {
43307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43308       };
43309     }
43310   }
43311
43312   jresult = (void *)result;
43313   return jresult;
43314 }
43315
43316
43317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43318   void * jresult ;
43319   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43320   Dali::KeyFrames *arg2 = 0 ;
43321   Dali::KeyFrames *result = 0 ;
43322
43323   arg1 = (Dali::KeyFrames *)jarg1;
43324   arg2 = (Dali::KeyFrames *)jarg2;
43325   if (!arg2) {
43326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43327     return 0;
43328   }
43329   {
43330     try {
43331       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43332     } catch (std::out_of_range& e) {
43333       {
43334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43335       };
43336     } catch (std::exception& e) {
43337       {
43338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43339       };
43340     } catch (Dali::DaliException e) {
43341       {
43342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43343       };
43344     } catch (...) {
43345       {
43346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43347       };
43348     }
43349   }
43350
43351   jresult = (void *)result;
43352   return jresult;
43353 }
43354
43355
43356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43357   int jresult ;
43358   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43359   Dali::Property::Type result;
43360
43361   arg1 = (Dali::KeyFrames *)jarg1;
43362   {
43363     try {
43364       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43365     } catch (std::out_of_range& e) {
43366       {
43367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43368       };
43369     } catch (std::exception& e) {
43370       {
43371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43372       };
43373     } catch (Dali::DaliException e) {
43374       {
43375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43376       };
43377     } catch (...) {
43378       {
43379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43380       };
43381     }
43382   }
43383
43384   jresult = (int)result;
43385   return jresult;
43386 }
43387
43388
43389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43390   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43391   float arg2 ;
43392   Dali::Property::Value arg3 ;
43393   Dali::Property::Value *argp3 ;
43394
43395   arg1 = (Dali::KeyFrames *)jarg1;
43396   arg2 = (float)jarg2;
43397   argp3 = (Dali::Property::Value *)jarg3;
43398   if (!argp3) {
43399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43400     return ;
43401   }
43402   arg3 = *argp3;
43403   {
43404     try {
43405       (arg1)->Add(arg2,arg3);
43406     } catch (std::out_of_range& e) {
43407       {
43408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43409       };
43410     } catch (std::exception& e) {
43411       {
43412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43413       };
43414     } catch (Dali::DaliException e) {
43415       {
43416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43417       };
43418     } catch (...) {
43419       {
43420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43421       };
43422     }
43423   }
43424
43425 }
43426
43427
43428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43429   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43430   float arg2 ;
43431   Dali::Property::Value arg3 ;
43432   Dali::AlphaFunction arg4 ;
43433   Dali::Property::Value *argp3 ;
43434   Dali::AlphaFunction *argp4 ;
43435
43436   arg1 = (Dali::KeyFrames *)jarg1;
43437   arg2 = (float)jarg2;
43438   argp3 = (Dali::Property::Value *)jarg3;
43439   if (!argp3) {
43440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43441     return ;
43442   }
43443   arg3 = *argp3;
43444   argp4 = (Dali::AlphaFunction *)jarg4;
43445   if (!argp4) {
43446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43447     return ;
43448   }
43449   arg4 = *argp4;
43450   {
43451     try {
43452       (arg1)->Add(arg2,arg3,arg4);
43453     } catch (std::out_of_range& e) {
43454       {
43455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43456       };
43457     } catch (std::exception& e) {
43458       {
43459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43460       };
43461     } catch (Dali::DaliException e) {
43462       {
43463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43464       };
43465     } catch (...) {
43466       {
43467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43468       };
43469     }
43470   }
43471
43472 }
43473
43474
43475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43476   int jresult ;
43477   int result;
43478
43479   result = (int)Dali::Path::Property::POINTS;
43480   jresult = (int)result;
43481   return jresult;
43482 }
43483
43484
43485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43486   int jresult ;
43487   int result;
43488
43489   result = (int)Dali::Path::Property::CONTROL_POINTS;
43490   jresult = (int)result;
43491   return jresult;
43492 }
43493
43494
43495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43496   void * jresult ;
43497   Dali::Path::Property *result = 0 ;
43498
43499   {
43500     try {
43501       result = (Dali::Path::Property *)new Dali::Path::Property();
43502     } catch (std::out_of_range& e) {
43503       {
43504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43505       };
43506     } catch (std::exception& e) {
43507       {
43508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43509       };
43510     } catch (Dali::DaliException e) {
43511       {
43512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43513       };
43514     } catch (...) {
43515       {
43516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43517       };
43518     }
43519   }
43520
43521   jresult = (void *)result;
43522   return jresult;
43523 }
43524
43525
43526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43527   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43528
43529   arg1 = (Dali::Path::Property *)jarg1;
43530   {
43531     try {
43532       delete arg1;
43533     } catch (std::out_of_range& e) {
43534       {
43535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43536       };
43537     } catch (std::exception& e) {
43538       {
43539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43540       };
43541     } catch (Dali::DaliException e) {
43542       {
43543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43544       };
43545     } catch (...) {
43546       {
43547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43548       };
43549     }
43550   }
43551
43552 }
43553
43554
43555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43556   void * jresult ;
43557   Dali::Path result;
43558
43559   {
43560     try {
43561       result = Dali::Path::New();
43562     } catch (std::out_of_range& e) {
43563       {
43564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43565       };
43566     } catch (std::exception& e) {
43567       {
43568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43569       };
43570     } catch (Dali::DaliException e) {
43571       {
43572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43573       };
43574     } catch (...) {
43575       {
43576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43577       };
43578     }
43579   }
43580
43581   jresult = new Dali::Path((const Dali::Path &)result);
43582   return jresult;
43583 }
43584
43585
43586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43587   void * jresult ;
43588   Dali::BaseHandle arg1 ;
43589   Dali::BaseHandle *argp1 ;
43590   Dali::Path result;
43591
43592   argp1 = (Dali::BaseHandle *)jarg1;
43593   if (!argp1) {
43594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43595     return 0;
43596   }
43597   arg1 = *argp1;
43598   {
43599     try {
43600       result = Dali::Path::DownCast(arg1);
43601     } catch (std::out_of_range& e) {
43602       {
43603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43604       };
43605     } catch (std::exception& e) {
43606       {
43607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43608       };
43609     } catch (Dali::DaliException e) {
43610       {
43611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43612       };
43613     } catch (...) {
43614       {
43615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43616       };
43617     }
43618   }
43619
43620   jresult = new Dali::Path((const Dali::Path &)result);
43621   return jresult;
43622 }
43623
43624
43625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43626   void * jresult ;
43627   Dali::Path *result = 0 ;
43628
43629   {
43630     try {
43631       result = (Dali::Path *)new Dali::Path();
43632     } catch (std::out_of_range& e) {
43633       {
43634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43635       };
43636     } catch (std::exception& e) {
43637       {
43638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43639       };
43640     } catch (Dali::DaliException e) {
43641       {
43642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43643       };
43644     } catch (...) {
43645       {
43646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43647       };
43648     }
43649   }
43650
43651   jresult = (void *)result;
43652   return jresult;
43653 }
43654
43655
43656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43657   Dali::Path *arg1 = (Dali::Path *) 0 ;
43658
43659   arg1 = (Dali::Path *)jarg1;
43660   {
43661     try {
43662       delete arg1;
43663     } catch (std::out_of_range& e) {
43664       {
43665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43666       };
43667     } catch (std::exception& e) {
43668       {
43669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43670       };
43671     } catch (Dali::DaliException e) {
43672       {
43673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43674       };
43675     } catch (...) {
43676       {
43677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43678       };
43679     }
43680   }
43681
43682 }
43683
43684
43685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43686   void * jresult ;
43687   Dali::Path *arg1 = 0 ;
43688   Dali::Path *result = 0 ;
43689
43690   arg1 = (Dali::Path *)jarg1;
43691   if (!arg1) {
43692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43693     return 0;
43694   }
43695   {
43696     try {
43697       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43698     } catch (std::out_of_range& e) {
43699       {
43700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43701       };
43702     } catch (std::exception& e) {
43703       {
43704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43705       };
43706     } catch (Dali::DaliException e) {
43707       {
43708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43709       };
43710     } catch (...) {
43711       {
43712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43713       };
43714     }
43715   }
43716
43717   jresult = (void *)result;
43718   return jresult;
43719 }
43720
43721
43722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43723   void * jresult ;
43724   Dali::Path *arg1 = (Dali::Path *) 0 ;
43725   Dali::Path *arg2 = 0 ;
43726   Dali::Path *result = 0 ;
43727
43728   arg1 = (Dali::Path *)jarg1;
43729   arg2 = (Dali::Path *)jarg2;
43730   if (!arg2) {
43731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43732     return 0;
43733   }
43734   {
43735     try {
43736       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43737     } catch (std::out_of_range& e) {
43738       {
43739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43740       };
43741     } catch (std::exception& e) {
43742       {
43743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43744       };
43745     } catch (Dali::DaliException e) {
43746       {
43747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43748       };
43749     } catch (...) {
43750       {
43751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43752       };
43753     }
43754   }
43755
43756   jresult = (void *)result;
43757   return jresult;
43758 }
43759
43760
43761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43762   Dali::Path *arg1 = (Dali::Path *) 0 ;
43763   Dali::Vector3 *arg2 = 0 ;
43764
43765   arg1 = (Dali::Path *)jarg1;
43766   arg2 = (Dali::Vector3 *)jarg2;
43767   if (!arg2) {
43768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43769     return ;
43770   }
43771   {
43772     try {
43773       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43774     } catch (std::out_of_range& e) {
43775       {
43776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43777       };
43778     } catch (std::exception& e) {
43779       {
43780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43781       };
43782     } catch (Dali::DaliException e) {
43783       {
43784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43785       };
43786     } catch (...) {
43787       {
43788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43789       };
43790     }
43791   }
43792
43793 }
43794
43795
43796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43797   Dali::Path *arg1 = (Dali::Path *) 0 ;
43798   Dali::Vector3 *arg2 = 0 ;
43799
43800   arg1 = (Dali::Path *)jarg1;
43801   arg2 = (Dali::Vector3 *)jarg2;
43802   if (!arg2) {
43803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43804     return ;
43805   }
43806   {
43807     try {
43808       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43809     } catch (std::out_of_range& e) {
43810       {
43811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43812       };
43813     } catch (std::exception& e) {
43814       {
43815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43816       };
43817     } catch (Dali::DaliException e) {
43818       {
43819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43820       };
43821     } catch (...) {
43822       {
43823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43824       };
43825     }
43826   }
43827
43828 }
43829
43830
43831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43832   Dali::Path *arg1 = (Dali::Path *) 0 ;
43833   float arg2 ;
43834
43835   arg1 = (Dali::Path *)jarg1;
43836   arg2 = (float)jarg2;
43837   {
43838     try {
43839       (arg1)->GenerateControlPoints(arg2);
43840     } catch (std::out_of_range& e) {
43841       {
43842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43843       };
43844     } catch (std::exception& e) {
43845       {
43846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43847       };
43848     } catch (Dali::DaliException e) {
43849       {
43850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43851       };
43852     } catch (...) {
43853       {
43854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43855       };
43856     }
43857   }
43858
43859 }
43860
43861
43862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43863   Dali::Path *arg1 = (Dali::Path *) 0 ;
43864   float arg2 ;
43865   Dali::Vector3 *arg3 = 0 ;
43866   Dali::Vector3 *arg4 = 0 ;
43867
43868   arg1 = (Dali::Path *)jarg1;
43869   arg2 = (float)jarg2;
43870   arg3 = (Dali::Vector3 *)jarg3;
43871   if (!arg3) {
43872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43873     return ;
43874   }
43875   arg4 = (Dali::Vector3 *)jarg4;
43876   if (!arg4) {
43877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43878     return ;
43879   }
43880   {
43881     try {
43882       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43883     } catch (std::out_of_range& e) {
43884       {
43885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43886       };
43887     } catch (std::exception& e) {
43888       {
43889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43890       };
43891     } catch (Dali::DaliException e) {
43892       {
43893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43894       };
43895     } catch (...) {
43896       {
43897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43898       };
43899     }
43900   }
43901
43902 }
43903
43904
43905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43906   void * jresult ;
43907   Dali::Path *arg1 = (Dali::Path *) 0 ;
43908   size_t arg2 ;
43909   Dali::Vector3 *result = 0 ;
43910
43911   arg1 = (Dali::Path *)jarg1;
43912   arg2 = (size_t)jarg2;
43913   {
43914     try {
43915       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43916     } catch (std::out_of_range& e) {
43917       {
43918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43919       };
43920     } catch (std::exception& e) {
43921       {
43922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43923       };
43924     } catch (Dali::DaliException e) {
43925       {
43926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43927       };
43928     } catch (...) {
43929       {
43930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43931       };
43932     }
43933   }
43934
43935   jresult = (void *)result;
43936   return jresult;
43937 }
43938
43939
43940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43941   void * jresult ;
43942   Dali::Path *arg1 = (Dali::Path *) 0 ;
43943   size_t arg2 ;
43944   Dali::Vector3 *result = 0 ;
43945
43946   arg1 = (Dali::Path *)jarg1;
43947   arg2 = (size_t)jarg2;
43948   {
43949     try {
43950       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43951     } catch (std::out_of_range& e) {
43952       {
43953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43954       };
43955     } catch (std::exception& e) {
43956       {
43957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43958       };
43959     } catch (Dali::DaliException e) {
43960       {
43961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43962       };
43963     } catch (...) {
43964       {
43965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43966       };
43967     }
43968   }
43969
43970   jresult = (void *)result;
43971   return jresult;
43972 }
43973
43974
43975 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43976   unsigned long jresult ;
43977   Dali::Path *arg1 = (Dali::Path *) 0 ;
43978   size_t result;
43979
43980   arg1 = (Dali::Path *)jarg1;
43981   {
43982     try {
43983       result = ((Dali::Path const *)arg1)->GetPointCount();
43984     } catch (std::out_of_range& e) {
43985       {
43986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43987       };
43988     } catch (std::exception& e) {
43989       {
43990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43991       };
43992     } catch (Dali::DaliException e) {
43993       {
43994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43995       };
43996     } catch (...) {
43997       {
43998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43999       };
44000     }
44001   }
44002
44003   jresult = (unsigned long)result;
44004   return jresult;
44005 }
44006
44007
44008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44009   void * jresult ;
44010   float arg1 ;
44011   Dali::TimePeriod *result = 0 ;
44012
44013   arg1 = (float)jarg1;
44014   {
44015     try {
44016       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44017     } catch (std::out_of_range& e) {
44018       {
44019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44020       };
44021     } catch (std::exception& e) {
44022       {
44023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44024       };
44025     } catch (Dali::DaliException e) {
44026       {
44027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44028       };
44029     } catch (...) {
44030       {
44031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44032       };
44033     }
44034   }
44035
44036   jresult = (void *)result;
44037   return jresult;
44038 }
44039
44040
44041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44042   void * jresult ;
44043   float arg1 ;
44044   float arg2 ;
44045   Dali::TimePeriod *result = 0 ;
44046
44047   arg1 = (float)jarg1;
44048   arg2 = (float)jarg2;
44049   {
44050     try {
44051       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44052     } catch (std::out_of_range& e) {
44053       {
44054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44055       };
44056     } catch (std::exception& e) {
44057       {
44058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44059       };
44060     } catch (Dali::DaliException e) {
44061       {
44062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44063       };
44064     } catch (...) {
44065       {
44066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44067       };
44068     }
44069   }
44070
44071   jresult = (void *)result;
44072   return jresult;
44073 }
44074
44075
44076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44077   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44078
44079   arg1 = (Dali::TimePeriod *)jarg1;
44080   {
44081     try {
44082       delete arg1;
44083     } catch (std::out_of_range& e) {
44084       {
44085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44086       };
44087     } catch (std::exception& e) {
44088       {
44089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44090       };
44091     } catch (Dali::DaliException e) {
44092       {
44093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44094       };
44095     } catch (...) {
44096       {
44097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44098       };
44099     }
44100   }
44101
44102 }
44103
44104
44105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44106   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44107   float arg2 ;
44108
44109   arg1 = (Dali::TimePeriod *)jarg1;
44110   arg2 = (float)jarg2;
44111   if (arg1) (arg1)->delaySeconds = arg2;
44112 }
44113
44114
44115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44116   float jresult ;
44117   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44118   float result;
44119
44120   arg1 = (Dali::TimePeriod *)jarg1;
44121   result = (float) ((arg1)->delaySeconds);
44122   jresult = result;
44123   return jresult;
44124 }
44125
44126
44127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44128   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44129   float arg2 ;
44130
44131   arg1 = (Dali::TimePeriod *)jarg1;
44132   arg2 = (float)jarg2;
44133   if (arg1) (arg1)->durationSeconds = arg2;
44134 }
44135
44136
44137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44138   float jresult ;
44139   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44140   float result;
44141
44142   arg1 = (Dali::TimePeriod *)jarg1;
44143   result = (float) ((arg1)->durationSeconds);
44144   jresult = result;
44145   return jresult;
44146 }
44147
44148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44149   int jresult ;
44150   int result;
44151
44152   result = (int)Dali::LinearConstrainer::Property::VALUE;
44153   jresult = (int)result;
44154   return jresult;
44155 }
44156
44157
44158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44159   int jresult ;
44160   int result;
44161
44162   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44163   jresult = (int)result;
44164   return jresult;
44165 }
44166
44167
44168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44169   void * jresult ;
44170   Dali::LinearConstrainer::Property *result = 0 ;
44171
44172   {
44173     try {
44174       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44175     } catch (std::out_of_range& e) {
44176       {
44177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44178       };
44179     } catch (std::exception& e) {
44180       {
44181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44182       };
44183     } catch (Dali::DaliException e) {
44184       {
44185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44186       };
44187     } catch (...) {
44188       {
44189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44190       };
44191     }
44192   }
44193
44194   jresult = (void *)result;
44195   return jresult;
44196 }
44197
44198
44199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44200   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44201
44202   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44203   {
44204     try {
44205       delete arg1;
44206     } catch (std::out_of_range& e) {
44207       {
44208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44209       };
44210     } catch (std::exception& e) {
44211       {
44212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44213       };
44214     } catch (Dali::DaliException e) {
44215       {
44216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44217       };
44218     } catch (...) {
44219       {
44220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44221       };
44222     }
44223   }
44224
44225 }
44226
44227
44228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44229   void * jresult ;
44230   Dali::LinearConstrainer result;
44231
44232   {
44233     try {
44234       result = Dali::LinearConstrainer::New();
44235     } catch (std::out_of_range& e) {
44236       {
44237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44238       };
44239     } catch (std::exception& e) {
44240       {
44241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44242       };
44243     } catch (Dali::DaliException e) {
44244       {
44245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44246       };
44247     } catch (...) {
44248       {
44249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44250       };
44251     }
44252   }
44253
44254   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44255   return jresult;
44256 }
44257
44258
44259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44260   void * jresult ;
44261   Dali::BaseHandle arg1 ;
44262   Dali::BaseHandle *argp1 ;
44263   Dali::LinearConstrainer result;
44264
44265   argp1 = (Dali::BaseHandle *)jarg1;
44266   if (!argp1) {
44267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44268     return 0;
44269   }
44270   arg1 = *argp1;
44271   {
44272     try {
44273       result = Dali::LinearConstrainer::DownCast(arg1);
44274     } catch (std::out_of_range& e) {
44275       {
44276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44277       };
44278     } catch (std::exception& e) {
44279       {
44280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44281       };
44282     } catch (Dali::DaliException e) {
44283       {
44284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44285       };
44286     } catch (...) {
44287       {
44288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44289       };
44290     }
44291   }
44292
44293   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44294   return jresult;
44295 }
44296
44297
44298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44299   void * jresult ;
44300   Dali::LinearConstrainer *result = 0 ;
44301
44302   {
44303     try {
44304       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44305     } catch (std::out_of_range& e) {
44306       {
44307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44308       };
44309     } catch (std::exception& e) {
44310       {
44311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44312       };
44313     } catch (Dali::DaliException e) {
44314       {
44315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44316       };
44317     } catch (...) {
44318       {
44319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44320       };
44321     }
44322   }
44323
44324   jresult = (void *)result;
44325   return jresult;
44326 }
44327
44328
44329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44330   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44331
44332   arg1 = (Dali::LinearConstrainer *)jarg1;
44333   {
44334     try {
44335       delete arg1;
44336     } catch (std::out_of_range& e) {
44337       {
44338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44339       };
44340     } catch (std::exception& e) {
44341       {
44342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44343       };
44344     } catch (Dali::DaliException e) {
44345       {
44346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44347       };
44348     } catch (...) {
44349       {
44350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44351       };
44352     }
44353   }
44354
44355 }
44356
44357
44358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44359   void * jresult ;
44360   Dali::LinearConstrainer *arg1 = 0 ;
44361   Dali::LinearConstrainer *result = 0 ;
44362
44363   arg1 = (Dali::LinearConstrainer *)jarg1;
44364   if (!arg1) {
44365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44366     return 0;
44367   }
44368   {
44369     try {
44370       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44371     } catch (std::out_of_range& e) {
44372       {
44373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44374       };
44375     } catch (std::exception& e) {
44376       {
44377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44378       };
44379     } catch (Dali::DaliException e) {
44380       {
44381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44382       };
44383     } catch (...) {
44384       {
44385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44386       };
44387     }
44388   }
44389
44390   jresult = (void *)result;
44391   return jresult;
44392 }
44393
44394
44395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44396   void * jresult ;
44397   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44398   Dali::LinearConstrainer *arg2 = 0 ;
44399   Dali::LinearConstrainer *result = 0 ;
44400
44401   arg1 = (Dali::LinearConstrainer *)jarg1;
44402   arg2 = (Dali::LinearConstrainer *)jarg2;
44403   if (!arg2) {
44404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44405     return 0;
44406   }
44407   {
44408     try {
44409       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44410     } catch (std::out_of_range& e) {
44411       {
44412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44413       };
44414     } catch (std::exception& e) {
44415       {
44416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44417       };
44418     } catch (Dali::DaliException e) {
44419       {
44420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44421       };
44422     } catch (...) {
44423       {
44424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44425       };
44426     }
44427   }
44428
44429   jresult = (void *)result;
44430   return jresult;
44431 }
44432
44433
44434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44435   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44436   SwigValueWrapper< Dali::Property > arg2 ;
44437   SwigValueWrapper< Dali::Property > arg3 ;
44438   Dali::Vector2 *arg4 = 0 ;
44439   Dali::Vector2 *arg5 = 0 ;
44440   Dali::Property *argp2 ;
44441   Dali::Property *argp3 ;
44442
44443   arg1 = (Dali::LinearConstrainer *)jarg1;
44444   argp2 = (Dali::Property *)jarg2;
44445   if (!argp2) {
44446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44447     return ;
44448   }
44449   arg2 = *argp2;
44450   argp3 = (Dali::Property *)jarg3;
44451   if (!argp3) {
44452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44453     return ;
44454   }
44455   arg3 = *argp3;
44456   arg4 = (Dali::Vector2 *)jarg4;
44457   if (!arg4) {
44458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44459     return ;
44460   }
44461   arg5 = (Dali::Vector2 *)jarg5;
44462   if (!arg5) {
44463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44464     return ;
44465   }
44466   {
44467     try {
44468       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44469     } catch (std::out_of_range& e) {
44470       {
44471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44472       };
44473     } catch (std::exception& e) {
44474       {
44475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44476       };
44477     } catch (Dali::DaliException e) {
44478       {
44479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44480       };
44481     } catch (...) {
44482       {
44483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44484       };
44485     }
44486   }
44487
44488 }
44489
44490
44491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44492   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44493   SwigValueWrapper< Dali::Property > arg2 ;
44494   SwigValueWrapper< Dali::Property > arg3 ;
44495   Dali::Vector2 *arg4 = 0 ;
44496   Dali::Property *argp2 ;
44497   Dali::Property *argp3 ;
44498
44499   arg1 = (Dali::LinearConstrainer *)jarg1;
44500   argp2 = (Dali::Property *)jarg2;
44501   if (!argp2) {
44502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44503     return ;
44504   }
44505   arg2 = *argp2;
44506   argp3 = (Dali::Property *)jarg3;
44507   if (!argp3) {
44508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44509     return ;
44510   }
44511   arg3 = *argp3;
44512   arg4 = (Dali::Vector2 *)jarg4;
44513   if (!arg4) {
44514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44515     return ;
44516   }
44517   {
44518     try {
44519       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44520     } catch (std::out_of_range& e) {
44521       {
44522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44523       };
44524     } catch (std::exception& e) {
44525       {
44526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44527       };
44528     } catch (Dali::DaliException e) {
44529       {
44530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44531       };
44532     } catch (...) {
44533       {
44534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44535       };
44536     }
44537   }
44538
44539 }
44540
44541
44542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44543   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44544   Dali::Handle *arg2 = 0 ;
44545
44546   arg1 = (Dali::LinearConstrainer *)jarg1;
44547   arg2 = (Dali::Handle *)jarg2;
44548   if (!arg2) {
44549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44550     return ;
44551   }
44552   {
44553     try {
44554       (arg1)->Remove(*arg2);
44555     } catch (std::out_of_range& e) {
44556       {
44557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44558       };
44559     } catch (std::exception& e) {
44560       {
44561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44562       };
44563     } catch (Dali::DaliException e) {
44564       {
44565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44566       };
44567     } catch (...) {
44568       {
44569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44570       };
44571     }
44572   }
44573
44574 }
44575
44576
44577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44578   int jresult ;
44579   int result;
44580
44581   result = (int)Dali::PathConstrainer::Property::FORWARD;
44582   jresult = (int)result;
44583   return jresult;
44584 }
44585
44586
44587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44588   int jresult ;
44589   int result;
44590
44591   result = (int)Dali::PathConstrainer::Property::POINTS;
44592   jresult = (int)result;
44593   return jresult;
44594 }
44595
44596
44597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44598   int jresult ;
44599   int result;
44600
44601   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44602   jresult = (int)result;
44603   return jresult;
44604 }
44605
44606
44607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44608   void * jresult ;
44609   Dali::PathConstrainer::Property *result = 0 ;
44610
44611   {
44612     try {
44613       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44614     } catch (std::out_of_range& e) {
44615       {
44616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44617       };
44618     } catch (std::exception& e) {
44619       {
44620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44621       };
44622     } catch (Dali::DaliException e) {
44623       {
44624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44625       };
44626     } catch (...) {
44627       {
44628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44629       };
44630     }
44631   }
44632
44633   jresult = (void *)result;
44634   return jresult;
44635 }
44636
44637
44638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44639   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44640
44641   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44642   {
44643     try {
44644       delete arg1;
44645     } catch (std::out_of_range& e) {
44646       {
44647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44648       };
44649     } catch (std::exception& e) {
44650       {
44651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44652       };
44653     } catch (Dali::DaliException e) {
44654       {
44655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44656       };
44657     } catch (...) {
44658       {
44659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44660       };
44661     }
44662   }
44663
44664 }
44665
44666
44667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44668   void * jresult ;
44669   Dali::PathConstrainer result;
44670
44671   {
44672     try {
44673       result = Dali::PathConstrainer::New();
44674     } catch (std::out_of_range& e) {
44675       {
44676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44677       };
44678     } catch (std::exception& e) {
44679       {
44680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44681       };
44682     } catch (Dali::DaliException e) {
44683       {
44684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44685       };
44686     } catch (...) {
44687       {
44688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44689       };
44690     }
44691   }
44692
44693   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44694   return jresult;
44695 }
44696
44697
44698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44699   void * jresult ;
44700   Dali::BaseHandle arg1 ;
44701   Dali::BaseHandle *argp1 ;
44702   Dali::PathConstrainer result;
44703
44704   argp1 = (Dali::BaseHandle *)jarg1;
44705   if (!argp1) {
44706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44707     return 0;
44708   }
44709   arg1 = *argp1;
44710   {
44711     try {
44712       result = Dali::PathConstrainer::DownCast(arg1);
44713     } catch (std::out_of_range& e) {
44714       {
44715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44716       };
44717     } catch (std::exception& e) {
44718       {
44719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44720       };
44721     } catch (Dali::DaliException e) {
44722       {
44723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44724       };
44725     } catch (...) {
44726       {
44727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44728       };
44729     }
44730   }
44731
44732   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44733   return jresult;
44734 }
44735
44736
44737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44738   void * jresult ;
44739   Dali::PathConstrainer *result = 0 ;
44740
44741   {
44742     try {
44743       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44744     } catch (std::out_of_range& e) {
44745       {
44746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44747       };
44748     } catch (std::exception& e) {
44749       {
44750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44751       };
44752     } catch (Dali::DaliException e) {
44753       {
44754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44755       };
44756     } catch (...) {
44757       {
44758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44759       };
44760     }
44761   }
44762
44763   jresult = (void *)result;
44764   return jresult;
44765 }
44766
44767
44768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44769   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44770
44771   arg1 = (Dali::PathConstrainer *)jarg1;
44772   {
44773     try {
44774       delete arg1;
44775     } catch (std::out_of_range& e) {
44776       {
44777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44778       };
44779     } catch (std::exception& e) {
44780       {
44781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44782       };
44783     } catch (Dali::DaliException e) {
44784       {
44785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44786       };
44787     } catch (...) {
44788       {
44789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44790       };
44791     }
44792   }
44793
44794 }
44795
44796
44797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44798   void * jresult ;
44799   Dali::PathConstrainer *arg1 = 0 ;
44800   Dali::PathConstrainer *result = 0 ;
44801
44802   arg1 = (Dali::PathConstrainer *)jarg1;
44803   if (!arg1) {
44804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44805     return 0;
44806   }
44807   {
44808     try {
44809       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44810     } catch (std::out_of_range& e) {
44811       {
44812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44813       };
44814     } catch (std::exception& e) {
44815       {
44816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44817       };
44818     } catch (Dali::DaliException e) {
44819       {
44820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44821       };
44822     } catch (...) {
44823       {
44824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44825       };
44826     }
44827   }
44828
44829   jresult = (void *)result;
44830   return jresult;
44831 }
44832
44833
44834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44835   void * jresult ;
44836   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44837   Dali::PathConstrainer *arg2 = 0 ;
44838   Dali::PathConstrainer *result = 0 ;
44839
44840   arg1 = (Dali::PathConstrainer *)jarg1;
44841   arg2 = (Dali::PathConstrainer *)jarg2;
44842   if (!arg2) {
44843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44844     return 0;
44845   }
44846   {
44847     try {
44848       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44849     } catch (std::out_of_range& e) {
44850       {
44851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44852       };
44853     } catch (std::exception& e) {
44854       {
44855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44856       };
44857     } catch (Dali::DaliException e) {
44858       {
44859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44860       };
44861     } catch (...) {
44862       {
44863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44864       };
44865     }
44866   }
44867
44868   jresult = (void *)result;
44869   return jresult;
44870 }
44871
44872
44873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44874   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44875   SwigValueWrapper< Dali::Property > arg2 ;
44876   SwigValueWrapper< Dali::Property > arg3 ;
44877   Dali::Vector2 *arg4 = 0 ;
44878   Dali::Vector2 *arg5 = 0 ;
44879   Dali::Property *argp2 ;
44880   Dali::Property *argp3 ;
44881
44882   arg1 = (Dali::PathConstrainer *)jarg1;
44883   argp2 = (Dali::Property *)jarg2;
44884   if (!argp2) {
44885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44886     return ;
44887   }
44888   arg2 = *argp2;
44889   argp3 = (Dali::Property *)jarg3;
44890   if (!argp3) {
44891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44892     return ;
44893   }
44894   arg3 = *argp3;
44895   arg4 = (Dali::Vector2 *)jarg4;
44896   if (!arg4) {
44897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44898     return ;
44899   }
44900   arg5 = (Dali::Vector2 *)jarg5;
44901   if (!arg5) {
44902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44903     return ;
44904   }
44905   {
44906     try {
44907       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44908     } catch (std::out_of_range& e) {
44909       {
44910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44911       };
44912     } catch (std::exception& e) {
44913       {
44914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44915       };
44916     } catch (Dali::DaliException e) {
44917       {
44918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44919       };
44920     } catch (...) {
44921       {
44922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44923       };
44924     }
44925   }
44926
44927 }
44928
44929
44930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44931   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44932   SwigValueWrapper< Dali::Property > arg2 ;
44933   SwigValueWrapper< Dali::Property > arg3 ;
44934   Dali::Vector2 *arg4 = 0 ;
44935   Dali::Property *argp2 ;
44936   Dali::Property *argp3 ;
44937
44938   arg1 = (Dali::PathConstrainer *)jarg1;
44939   argp2 = (Dali::Property *)jarg2;
44940   if (!argp2) {
44941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44942     return ;
44943   }
44944   arg2 = *argp2;
44945   argp3 = (Dali::Property *)jarg3;
44946   if (!argp3) {
44947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44948     return ;
44949   }
44950   arg3 = *argp3;
44951   arg4 = (Dali::Vector2 *)jarg4;
44952   if (!arg4) {
44953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44954     return ;
44955   }
44956   {
44957     try {
44958       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44959     } catch (std::out_of_range& e) {
44960       {
44961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44962       };
44963     } catch (std::exception& e) {
44964       {
44965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44966       };
44967     } catch (Dali::DaliException e) {
44968       {
44969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44970       };
44971     } catch (...) {
44972       {
44973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44974       };
44975     }
44976   }
44977
44978 }
44979
44980
44981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44982   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44983   Dali::Handle *arg2 = 0 ;
44984
44985   arg1 = (Dali::PathConstrainer *)jarg1;
44986   arg2 = (Dali::Handle *)jarg2;
44987   if (!arg2) {
44988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44989     return ;
44990   }
44991   {
44992     try {
44993       (arg1)->Remove(*arg2);
44994     } catch (std::out_of_range& e) {
44995       {
44996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44997       };
44998     } catch (std::exception& e) {
44999       {
45000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45001       };
45002     } catch (Dali::DaliException e) {
45003       {
45004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45005       };
45006     } catch (...) {
45007       {
45008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45009       };
45010     }
45011   }
45012
45013 }
45014
45015
45016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45017   int jresult ;
45018   Dali::FittingMode::Type result;
45019
45020   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45021   jresult = (int)result;
45022   return jresult;
45023 }
45024
45025
45026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45027   int jresult ;
45028   Dali::SamplingMode::Type result;
45029
45030   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45031   jresult = (int)result;
45032   return jresult;
45033 }
45034
45035
45036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45037   void * jresult ;
45038   Dali::BufferImage *result = 0 ;
45039
45040   {
45041     try {
45042       result = (Dali::BufferImage *)new Dali::BufferImage();
45043     } catch (std::out_of_range& e) {
45044       {
45045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45046       };
45047     } catch (std::exception& e) {
45048       {
45049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45050       };
45051     } catch (Dali::DaliException e) {
45052       {
45053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45054       };
45055     } catch (...) {
45056       {
45057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45058       };
45059     }
45060   }
45061
45062   jresult = (void *)result;
45063   return jresult;
45064 }
45065
45066
45067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45068   void * jresult ;
45069   unsigned int arg1 ;
45070   unsigned int arg2 ;
45071   Dali::Pixel::Format arg3 ;
45072   Dali::BufferImage result;
45073
45074   arg1 = (unsigned int)jarg1;
45075   arg2 = (unsigned int)jarg2;
45076   arg3 = (Dali::Pixel::Format)jarg3;
45077   {
45078     try {
45079       result = Dali::BufferImage::New(arg1,arg2,arg3);
45080     } catch (std::out_of_range& e) {
45081       {
45082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45083       };
45084     } catch (std::exception& e) {
45085       {
45086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45087       };
45088     } catch (Dali::DaliException e) {
45089       {
45090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45091       };
45092     } catch (...) {
45093       {
45094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45095       };
45096     }
45097   }
45098
45099   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45100   return jresult;
45101 }
45102
45103
45104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45105   void * jresult ;
45106   unsigned int arg1 ;
45107   unsigned int arg2 ;
45108   Dali::BufferImage result;
45109
45110   arg1 = (unsigned int)jarg1;
45111   arg2 = (unsigned int)jarg2;
45112   {
45113     try {
45114       result = Dali::BufferImage::New(arg1,arg2);
45115     } catch (std::out_of_range& e) {
45116       {
45117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45118       };
45119     } catch (std::exception& e) {
45120       {
45121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45122       };
45123     } catch (Dali::DaliException e) {
45124       {
45125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45126       };
45127     } catch (...) {
45128       {
45129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45130       };
45131     }
45132   }
45133
45134   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45135   return jresult;
45136 }
45137
45138
45139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45140   void * jresult ;
45141   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45142   unsigned int arg2 ;
45143   unsigned int arg3 ;
45144   Dali::Pixel::Format arg4 ;
45145   unsigned int arg5 ;
45146   Dali::BufferImage result;
45147
45148   arg1 = jarg1;
45149   arg2 = (unsigned int)jarg2;
45150   arg3 = (unsigned int)jarg3;
45151   arg4 = (Dali::Pixel::Format)jarg4;
45152   arg5 = (unsigned int)jarg5;
45153   {
45154     try {
45155       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45156     } catch (std::out_of_range& e) {
45157       {
45158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45159       };
45160     } catch (std::exception& e) {
45161       {
45162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45163       };
45164     } catch (Dali::DaliException e) {
45165       {
45166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45167       };
45168     } catch (...) {
45169       {
45170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45171       };
45172     }
45173   }
45174
45175   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45176
45177
45178   return jresult;
45179 }
45180
45181
45182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45183   void * jresult ;
45184   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45185   unsigned int arg2 ;
45186   unsigned int arg3 ;
45187   Dali::Pixel::Format arg4 ;
45188   Dali::BufferImage result;
45189
45190   arg1 = jarg1;
45191   arg2 = (unsigned int)jarg2;
45192   arg3 = (unsigned int)jarg3;
45193   arg4 = (Dali::Pixel::Format)jarg4;
45194   {
45195     try {
45196       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45197     } catch (std::out_of_range& e) {
45198       {
45199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45200       };
45201     } catch (std::exception& e) {
45202       {
45203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45204       };
45205     } catch (Dali::DaliException e) {
45206       {
45207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45208       };
45209     } catch (...) {
45210       {
45211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45212       };
45213     }
45214   }
45215
45216   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45217
45218
45219   return jresult;
45220 }
45221
45222
45223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45224   void * jresult ;
45225   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45226   unsigned int arg2 ;
45227   unsigned int arg3 ;
45228   Dali::BufferImage result;
45229
45230   arg1 = jarg1;
45231   arg2 = (unsigned int)jarg2;
45232   arg3 = (unsigned int)jarg3;
45233   {
45234     try {
45235       result = Dali::BufferImage::New(arg1,arg2,arg3);
45236     } catch (std::out_of_range& e) {
45237       {
45238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45239       };
45240     } catch (std::exception& e) {
45241       {
45242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45243       };
45244     } catch (Dali::DaliException e) {
45245       {
45246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45247       };
45248     } catch (...) {
45249       {
45250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45251       };
45252     }
45253   }
45254
45255   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45256
45257
45258   return jresult;
45259 }
45260
45261
45262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45263   void * jresult ;
45264   Dali::BaseHandle arg1 ;
45265   Dali::BaseHandle *argp1 ;
45266   Dali::BufferImage result;
45267
45268   argp1 = (Dali::BaseHandle *)jarg1;
45269   if (!argp1) {
45270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45271     return 0;
45272   }
45273   arg1 = *argp1;
45274   {
45275     try {
45276       result = Dali::BufferImage::DownCast(arg1);
45277     } catch (std::out_of_range& e) {
45278       {
45279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45280       };
45281     } catch (std::exception& e) {
45282       {
45283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45284       };
45285     } catch (Dali::DaliException e) {
45286       {
45287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45288       };
45289     } catch (...) {
45290       {
45291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45292       };
45293     }
45294   }
45295
45296   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45297   return jresult;
45298 }
45299
45300
45301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45302   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45303
45304   arg1 = (Dali::BufferImage *)jarg1;
45305   {
45306     try {
45307       delete arg1;
45308     } catch (std::out_of_range& e) {
45309       {
45310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45311       };
45312     } catch (std::exception& e) {
45313       {
45314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45315       };
45316     } catch (Dali::DaliException e) {
45317       {
45318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45319       };
45320     } catch (...) {
45321       {
45322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45323       };
45324     }
45325   }
45326
45327 }
45328
45329
45330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45331   void * jresult ;
45332   Dali::BufferImage *arg1 = 0 ;
45333   Dali::BufferImage *result = 0 ;
45334
45335   arg1 = (Dali::BufferImage *)jarg1;
45336   if (!arg1) {
45337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45338     return 0;
45339   }
45340   {
45341     try {
45342       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45343     } catch (std::out_of_range& e) {
45344       {
45345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45346       };
45347     } catch (std::exception& e) {
45348       {
45349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45350       };
45351     } catch (Dali::DaliException e) {
45352       {
45353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45354       };
45355     } catch (...) {
45356       {
45357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45358       };
45359     }
45360   }
45361
45362   jresult = (void *)result;
45363   return jresult;
45364 }
45365
45366
45367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45368   void * jresult ;
45369   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45370   Dali::BufferImage *arg2 = 0 ;
45371   Dali::BufferImage *result = 0 ;
45372
45373   arg1 = (Dali::BufferImage *)jarg1;
45374   arg2 = (Dali::BufferImage *)jarg2;
45375   if (!arg2) {
45376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45377     return 0;
45378   }
45379   {
45380     try {
45381       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45382     } catch (std::out_of_range& e) {
45383       {
45384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45385       };
45386     } catch (std::exception& e) {
45387       {
45388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45389       };
45390     } catch (Dali::DaliException e) {
45391       {
45392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45393       };
45394     } catch (...) {
45395       {
45396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45397       };
45398     }
45399   }
45400
45401   jresult = (void *)result;
45402   return jresult;
45403 }
45404
45405
45406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45407   void * jresult ;
45408   Dali::BufferImage result;
45409
45410   {
45411     try {
45412       result = Dali::BufferImage::WHITE();
45413     } catch (std::out_of_range& e) {
45414       {
45415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45416       };
45417     } catch (std::exception& e) {
45418       {
45419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45420       };
45421     } catch (Dali::DaliException e) {
45422       {
45423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45424       };
45425     } catch (...) {
45426       {
45427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45428       };
45429     }
45430   }
45431
45432   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45433   return jresult;
45434 }
45435
45436
45437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45438   void * jresult ;
45439   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45440   Dali::PixelBuffer *result = 0 ;
45441
45442   arg1 = (Dali::BufferImage *)jarg1;
45443   {
45444     try {
45445       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45446     } catch (std::out_of_range& e) {
45447       {
45448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45449       };
45450     } catch (std::exception& e) {
45451       {
45452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45453       };
45454     } catch (Dali::DaliException e) {
45455       {
45456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45457       };
45458     } catch (...) {
45459       {
45460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45461       };
45462     }
45463   }
45464
45465   jresult = (void *)result;
45466   return jresult;
45467 }
45468
45469
45470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45471   unsigned int jresult ;
45472   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45473   unsigned int result;
45474
45475   arg1 = (Dali::BufferImage *)jarg1;
45476   {
45477     try {
45478       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45479     } catch (std::out_of_range& e) {
45480       {
45481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45482       };
45483     } catch (std::exception& e) {
45484       {
45485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45486       };
45487     } catch (Dali::DaliException e) {
45488       {
45489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45490       };
45491     } catch (...) {
45492       {
45493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45494       };
45495     }
45496   }
45497
45498   jresult = result;
45499   return jresult;
45500 }
45501
45502
45503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45504   unsigned int jresult ;
45505   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45506   unsigned int result;
45507
45508   arg1 = (Dali::BufferImage *)jarg1;
45509   {
45510     try {
45511       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45512     } catch (std::out_of_range& e) {
45513       {
45514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45515       };
45516     } catch (std::exception& e) {
45517       {
45518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45519       };
45520     } catch (Dali::DaliException e) {
45521       {
45522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45523       };
45524     } catch (...) {
45525       {
45526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45527       };
45528     }
45529   }
45530
45531   jresult = result;
45532   return jresult;
45533 }
45534
45535
45536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45537   int jresult ;
45538   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45539   Dali::Pixel::Format result;
45540
45541   arg1 = (Dali::BufferImage *)jarg1;
45542   {
45543     try {
45544       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45545     } catch (std::out_of_range& e) {
45546       {
45547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45548       };
45549     } catch (std::exception& e) {
45550       {
45551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45552       };
45553     } catch (Dali::DaliException e) {
45554       {
45555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45556       };
45557     } catch (...) {
45558       {
45559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45560       };
45561     }
45562   }
45563
45564   jresult = (int)result;
45565   return jresult;
45566 }
45567
45568
45569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45570   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45571
45572   arg1 = (Dali::BufferImage *)jarg1;
45573   {
45574     try {
45575       (arg1)->Update();
45576     } catch (std::out_of_range& e) {
45577       {
45578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45579       };
45580     } catch (std::exception& e) {
45581       {
45582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45583       };
45584     } catch (Dali::DaliException e) {
45585       {
45586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45587       };
45588     } catch (...) {
45589       {
45590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45591       };
45592     }
45593   }
45594
45595 }
45596
45597
45598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45599   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45600   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45601   Dali::RectArea *argp2 ;
45602
45603   arg1 = (Dali::BufferImage *)jarg1;
45604   argp2 = (Dali::RectArea *)jarg2;
45605   if (!argp2) {
45606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45607     return ;
45608   }
45609   arg2 = *argp2;
45610   {
45611     try {
45612       (arg1)->Update(arg2);
45613     } catch (std::out_of_range& e) {
45614       {
45615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45616       };
45617     } catch (std::exception& e) {
45618       {
45619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45620       };
45621     } catch (Dali::DaliException e) {
45622       {
45623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45624       };
45625     } catch (...) {
45626       {
45627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45628       };
45629     }
45630   }
45631
45632 }
45633
45634
45635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45636   unsigned int jresult ;
45637   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45638   bool result;
45639
45640   arg1 = (Dali::BufferImage *)jarg1;
45641   {
45642     try {
45643       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45644     } catch (std::out_of_range& e) {
45645       {
45646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45647       };
45648     } catch (std::exception& e) {
45649       {
45650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45651       };
45652     } catch (Dali::DaliException e) {
45653       {
45654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45655       };
45656     } catch (...) {
45657       {
45658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45659       };
45660     }
45661   }
45662
45663   jresult = result;
45664   return jresult;
45665 }
45666
45667
45668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45669   void * jresult ;
45670   Dali::EncodedBufferImage *result = 0 ;
45671
45672   {
45673     try {
45674       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45675     } catch (std::out_of_range& e) {
45676       {
45677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45678       };
45679     } catch (std::exception& e) {
45680       {
45681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45682       };
45683     } catch (Dali::DaliException e) {
45684       {
45685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45686       };
45687     } catch (...) {
45688       {
45689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45690       };
45691     }
45692   }
45693
45694   jresult = (void *)result;
45695   return jresult;
45696 }
45697
45698
45699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45700   void * jresult ;
45701   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45702   std::size_t arg2 ;
45703   Dali::EncodedBufferImage result;
45704
45705   arg1 = (uint8_t *)jarg1;
45706   arg2 = (std::size_t)jarg2;
45707   {
45708     try {
45709       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45710     } catch (std::out_of_range& e) {
45711       {
45712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45713       };
45714     } catch (std::exception& e) {
45715       {
45716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45717       };
45718     } catch (Dali::DaliException e) {
45719       {
45720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45721       };
45722     } catch (...) {
45723       {
45724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45725       };
45726     }
45727   }
45728
45729   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45730   return jresult;
45731 }
45732
45733
45734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45735   void * jresult ;
45736   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45737   std::size_t arg2 ;
45738   Dali::ImageDimensions arg3 ;
45739   Dali::FittingMode::Type arg4 ;
45740   Dali::SamplingMode::Type arg5 ;
45741   bool arg6 ;
45742   Dali::ImageDimensions *argp3 ;
45743   Dali::EncodedBufferImage result;
45744
45745   arg1 = (uint8_t *)jarg1;
45746   arg2 = (std::size_t)jarg2;
45747   argp3 = (Dali::ImageDimensions *)jarg3;
45748   if (!argp3) {
45749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45750     return 0;
45751   }
45752   arg3 = *argp3;
45753   arg4 = (Dali::FittingMode::Type)jarg4;
45754   arg5 = (Dali::SamplingMode::Type)jarg5;
45755   arg6 = jarg6 ? true : false;
45756   {
45757     try {
45758       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45759     } catch (std::out_of_range& e) {
45760       {
45761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45762       };
45763     } catch (std::exception& e) {
45764       {
45765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45766       };
45767     } catch (Dali::DaliException e) {
45768       {
45769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45770       };
45771     } catch (...) {
45772       {
45773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45774       };
45775     }
45776   }
45777
45778   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45779   return jresult;
45780 }
45781
45782
45783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45784   void * jresult ;
45785   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45786   std::size_t arg2 ;
45787   Dali::ImageDimensions arg3 ;
45788   Dali::FittingMode::Type arg4 ;
45789   Dali::SamplingMode::Type arg5 ;
45790   Dali::ImageDimensions *argp3 ;
45791   Dali::EncodedBufferImage result;
45792
45793   arg1 = (uint8_t *)jarg1;
45794   arg2 = (std::size_t)jarg2;
45795   argp3 = (Dali::ImageDimensions *)jarg3;
45796   if (!argp3) {
45797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45798     return 0;
45799   }
45800   arg3 = *argp3;
45801   arg4 = (Dali::FittingMode::Type)jarg4;
45802   arg5 = (Dali::SamplingMode::Type)jarg5;
45803   {
45804     try {
45805       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45806     } catch (std::out_of_range& e) {
45807       {
45808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45809       };
45810     } catch (std::exception& e) {
45811       {
45812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45813       };
45814     } catch (Dali::DaliException e) {
45815       {
45816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45817       };
45818     } catch (...) {
45819       {
45820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45821       };
45822     }
45823   }
45824
45825   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45826   return jresult;
45827 }
45828
45829
45830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45831   void * jresult ;
45832   Dali::BaseHandle arg1 ;
45833   Dali::BaseHandle *argp1 ;
45834   Dali::EncodedBufferImage result;
45835
45836   argp1 = (Dali::BaseHandle *)jarg1;
45837   if (!argp1) {
45838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45839     return 0;
45840   }
45841   arg1 = *argp1;
45842   {
45843     try {
45844       result = Dali::EncodedBufferImage::DownCast(arg1);
45845     } catch (std::out_of_range& e) {
45846       {
45847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45848       };
45849     } catch (std::exception& e) {
45850       {
45851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45852       };
45853     } catch (Dali::DaliException e) {
45854       {
45855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45856       };
45857     } catch (...) {
45858       {
45859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45860       };
45861     }
45862   }
45863
45864   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45865   return jresult;
45866 }
45867
45868
45869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45870   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45871
45872   arg1 = (Dali::EncodedBufferImage *)jarg1;
45873   {
45874     try {
45875       delete arg1;
45876     } catch (std::out_of_range& e) {
45877       {
45878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45879       };
45880     } catch (std::exception& e) {
45881       {
45882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45883       };
45884     } catch (Dali::DaliException e) {
45885       {
45886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45887       };
45888     } catch (...) {
45889       {
45890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45891       };
45892     }
45893   }
45894
45895 }
45896
45897
45898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45899   void * jresult ;
45900   Dali::EncodedBufferImage *arg1 = 0 ;
45901   Dali::EncodedBufferImage *result = 0 ;
45902
45903   arg1 = (Dali::EncodedBufferImage *)jarg1;
45904   if (!arg1) {
45905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45906     return 0;
45907   }
45908   {
45909     try {
45910       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45911     } catch (std::out_of_range& e) {
45912       {
45913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45914       };
45915     } catch (std::exception& e) {
45916       {
45917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45918       };
45919     } catch (Dali::DaliException e) {
45920       {
45921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45922       };
45923     } catch (...) {
45924       {
45925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45926       };
45927     }
45928   }
45929
45930   jresult = (void *)result;
45931   return jresult;
45932 }
45933
45934
45935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45936   void * jresult ;
45937   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45938   Dali::EncodedBufferImage *arg2 = 0 ;
45939   Dali::EncodedBufferImage *result = 0 ;
45940
45941   arg1 = (Dali::EncodedBufferImage *)jarg1;
45942   arg2 = (Dali::EncodedBufferImage *)jarg2;
45943   if (!arg2) {
45944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45945     return 0;
45946   }
45947   {
45948     try {
45949       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45950     } catch (std::out_of_range& e) {
45951       {
45952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45953       };
45954     } catch (std::exception& e) {
45955       {
45956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45957       };
45958     } catch (Dali::DaliException e) {
45959       {
45960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45961       };
45962     } catch (...) {
45963       {
45964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45965       };
45966     }
45967   }
45968
45969   jresult = (void *)result;
45970   return jresult;
45971 }
45972
45973
45974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45975   void * jresult ;
45976   Dali::NativeImage *result = 0 ;
45977
45978   {
45979     try {
45980       result = (Dali::NativeImage *)new Dali::NativeImage();
45981     } catch (std::out_of_range& e) {
45982       {
45983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45984       };
45985     } catch (std::exception& e) {
45986       {
45987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45988       };
45989     } catch (Dali::DaliException e) {
45990       {
45991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45992       };
45993     } catch (...) {
45994       {
45995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45996       };
45997     }
45998   }
45999
46000   jresult = (void *)result;
46001   return jresult;
46002 }
46003
46004
46005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46006   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46007
46008   arg1 = (Dali::NativeImage *)jarg1;
46009   {
46010     try {
46011       delete arg1;
46012     } catch (std::out_of_range& e) {
46013       {
46014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46015       };
46016     } catch (std::exception& e) {
46017       {
46018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46019       };
46020     } catch (Dali::DaliException e) {
46021       {
46022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46023       };
46024     } catch (...) {
46025       {
46026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46027       };
46028     }
46029   }
46030
46031 }
46032
46033
46034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46035   void * jresult ;
46036   Dali::NativeImage *arg1 = 0 ;
46037   Dali::NativeImage *result = 0 ;
46038
46039   arg1 = (Dali::NativeImage *)jarg1;
46040   if (!arg1) {
46041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46042     return 0;
46043   }
46044   {
46045     try {
46046       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46047     } catch (std::out_of_range& e) {
46048       {
46049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46050       };
46051     } catch (std::exception& e) {
46052       {
46053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46054       };
46055     } catch (Dali::DaliException e) {
46056       {
46057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46058       };
46059     } catch (...) {
46060       {
46061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46062       };
46063     }
46064   }
46065
46066   jresult = (void *)result;
46067   return jresult;
46068 }
46069
46070
46071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46072   void * jresult ;
46073   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46074   Dali::NativeImage *arg2 = 0 ;
46075   Dali::NativeImage *result = 0 ;
46076
46077   arg1 = (Dali::NativeImage *)jarg1;
46078   arg2 = (Dali::NativeImage *)jarg2;
46079   if (!arg2) {
46080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46081     return 0;
46082   }
46083   {
46084     try {
46085       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46086     } catch (std::out_of_range& e) {
46087       {
46088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46089       };
46090     } catch (std::exception& e) {
46091       {
46092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46093       };
46094     } catch (Dali::DaliException e) {
46095       {
46096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46097       };
46098     } catch (...) {
46099       {
46100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46101       };
46102     }
46103   }
46104
46105   jresult = (void *)result;
46106   return jresult;
46107 }
46108
46109
46110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46111   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46112
46113   arg1 = (Dali::NativeImage *)jarg1;
46114   {
46115     try {
46116       (arg1)->CreateGlTexture();
46117     } catch (std::out_of_range& e) {
46118       {
46119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46120       };
46121     } catch (std::exception& e) {
46122       {
46123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46124       };
46125     } catch (Dali::DaliException e) {
46126       {
46127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46128       };
46129     } catch (...) {
46130       {
46131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46132       };
46133     }
46134   }
46135
46136 }
46137
46138
46139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46140   void * jresult ;
46141   NativeImageInterface *arg1 = 0 ;
46142   Dali::NativeImage result;
46143
46144   arg1 = (NativeImageInterface *)jarg1;
46145   if (!arg1) {
46146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46147     return 0;
46148   }
46149   {
46150     try {
46151       result = Dali::NativeImage::New(*arg1);
46152     } catch (std::out_of_range& e) {
46153       {
46154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46155       };
46156     } catch (std::exception& e) {
46157       {
46158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46159       };
46160     } catch (Dali::DaliException e) {
46161       {
46162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46163       };
46164     } catch (...) {
46165       {
46166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46167       };
46168     }
46169   }
46170
46171   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46172   return jresult;
46173 }
46174
46175
46176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46177   void * jresult ;
46178   Dali::BaseHandle arg1 ;
46179   Dali::BaseHandle *argp1 ;
46180   Dali::NativeImage result;
46181
46182   argp1 = (Dali::BaseHandle *)jarg1;
46183   if (!argp1) {
46184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46185     return 0;
46186   }
46187   arg1 = *argp1;
46188   {
46189     try {
46190       result = Dali::NativeImage::DownCast(arg1);
46191     } catch (std::out_of_range& e) {
46192       {
46193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46194       };
46195     } catch (std::exception& e) {
46196       {
46197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46198       };
46199     } catch (Dali::DaliException e) {
46200       {
46201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46202       };
46203     } catch (...) {
46204       {
46205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46206       };
46207     }
46208   }
46209
46210   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46211   return jresult;
46212 }
46213
46214
46215 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46216   char * jresult ;
46217   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46218   char *result = 0 ;
46219
46220   arg1 = (Dali::NativeImage *)jarg1;
46221   {
46222     try {
46223       result = (char *)(arg1)->GetCustomFragmentPreFix();
46224     } catch (std::out_of_range& e) {
46225       {
46226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46227       };
46228     } catch (std::exception& e) {
46229       {
46230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46231       };
46232     } catch (Dali::DaliException e) {
46233       {
46234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46235       };
46236     } catch (...) {
46237       {
46238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46239       };
46240     }
46241   }
46242
46243   jresult = SWIG_csharp_string_callback((const char *)result);
46244   return jresult;
46245 }
46246
46247
46248 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46249   char * jresult ;
46250   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46251   char *result = 0 ;
46252
46253   arg1 = (Dali::NativeImage *)jarg1;
46254   {
46255     try {
46256       result = (char *)(arg1)->GetCustomSamplerTypename();
46257     } catch (std::out_of_range& e) {
46258       {
46259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46260       };
46261     } catch (std::exception& e) {
46262       {
46263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46264       };
46265     } catch (Dali::DaliException e) {
46266       {
46267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46268       };
46269     } catch (...) {
46270       {
46271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46272       };
46273     }
46274   }
46275
46276   jresult = SWIG_csharp_string_callback((const char *)result);
46277   return jresult;
46278 }
46279
46280
46281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46282   unsigned int jresult ;
46283   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46284   bool result;
46285
46286   arg1 = (Dali::NativeImageInterface *)jarg1;
46287   {
46288     try {
46289       result = (bool)(arg1)->GlExtensionCreate();
46290     } catch (std::out_of_range& e) {
46291       {
46292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46293       };
46294     } catch (std::exception& e) {
46295       {
46296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46297       };
46298     } catch (Dali::DaliException e) {
46299       {
46300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46301       };
46302     } catch (...) {
46303       {
46304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46305       };
46306     }
46307   }
46308
46309   jresult = result;
46310   return jresult;
46311 }
46312
46313
46314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46315   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46316
46317   arg1 = (Dali::NativeImageInterface *)jarg1;
46318   {
46319     try {
46320       (arg1)->GlExtensionDestroy();
46321     } catch (std::out_of_range& e) {
46322       {
46323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46324       };
46325     } catch (std::exception& e) {
46326       {
46327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46328       };
46329     } catch (Dali::DaliException e) {
46330       {
46331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46332       };
46333     } catch (...) {
46334       {
46335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46336       };
46337     }
46338   }
46339
46340 }
46341
46342
46343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46344   unsigned int jresult ;
46345   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46346   unsigned int result;
46347
46348   arg1 = (Dali::NativeImageInterface *)jarg1;
46349   {
46350     try {
46351       result = (unsigned int)(arg1)->TargetTexture();
46352     } catch (std::out_of_range& e) {
46353       {
46354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46355       };
46356     } catch (std::exception& e) {
46357       {
46358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46359       };
46360     } catch (Dali::DaliException e) {
46361       {
46362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46363       };
46364     } catch (...) {
46365       {
46366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46367       };
46368     }
46369   }
46370
46371   jresult = result;
46372   return jresult;
46373 }
46374
46375
46376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46377   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46378
46379   arg1 = (Dali::NativeImageInterface *)jarg1;
46380   {
46381     try {
46382       (arg1)->PrepareTexture();
46383     } catch (std::out_of_range& e) {
46384       {
46385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46386       };
46387     } catch (std::exception& e) {
46388       {
46389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46390       };
46391     } catch (Dali::DaliException e) {
46392       {
46393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46394       };
46395     } catch (...) {
46396       {
46397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46398       };
46399     }
46400   }
46401
46402 }
46403
46404
46405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46406   unsigned int jresult ;
46407   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46408   unsigned int result;
46409
46410   arg1 = (Dali::NativeImageInterface *)jarg1;
46411   {
46412     try {
46413       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46414     } catch (std::out_of_range& e) {
46415       {
46416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46417       };
46418     } catch (std::exception& e) {
46419       {
46420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46421       };
46422     } catch (Dali::DaliException e) {
46423       {
46424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46425       };
46426     } catch (...) {
46427       {
46428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46429       };
46430     }
46431   }
46432
46433   jresult = result;
46434   return jresult;
46435 }
46436
46437
46438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46439   unsigned int jresult ;
46440   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46441   unsigned int result;
46442
46443   arg1 = (Dali::NativeImageInterface *)jarg1;
46444   {
46445     try {
46446       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46447     } catch (std::out_of_range& e) {
46448       {
46449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46450       };
46451     } catch (std::exception& e) {
46452       {
46453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46454       };
46455     } catch (Dali::DaliException e) {
46456       {
46457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46458       };
46459     } catch (...) {
46460       {
46461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46462       };
46463     }
46464   }
46465
46466   jresult = result;
46467   return jresult;
46468 }
46469
46470
46471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46472   unsigned int jresult ;
46473   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46474   bool result;
46475
46476   arg1 = (Dali::NativeImageInterface *)jarg1;
46477   {
46478     try {
46479       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46480     } catch (std::out_of_range& e) {
46481       {
46482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46483       };
46484     } catch (std::exception& e) {
46485       {
46486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46487       };
46488     } catch (Dali::DaliException e) {
46489       {
46490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46491       };
46492     } catch (...) {
46493       {
46494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46495       };
46496     }
46497   }
46498
46499   jresult = result;
46500   return jresult;
46501 }
46502
46503
46504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46505   void * jresult ;
46506   std::string *arg1 = 0 ;
46507   Dali::ImageDimensions result;
46508
46509   if (!jarg1) {
46510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46511     return 0;
46512   }
46513   std::string arg1_str(jarg1);
46514   arg1 = &arg1_str;
46515   {
46516     try {
46517       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46518     } catch (std::out_of_range& e) {
46519       {
46520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46521       };
46522     } catch (std::exception& e) {
46523       {
46524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46525       };
46526     } catch (Dali::DaliException e) {
46527       {
46528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46529       };
46530     } catch (...) {
46531       {
46532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46533       };
46534     }
46535   }
46536
46537   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46538
46539   //argout typemap for const std::string&
46540
46541   return jresult;
46542 }
46543
46544
46545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46546   void * jresult ;
46547   Dali::ResourceImage *result = 0 ;
46548
46549   {
46550     try {
46551       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46552     } catch (std::out_of_range& e) {
46553       {
46554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46555       };
46556     } catch (std::exception& e) {
46557       {
46558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46559       };
46560     } catch (Dali::DaliException e) {
46561       {
46562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46563       };
46564     } catch (...) {
46565       {
46566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46567       };
46568     }
46569   }
46570
46571   jresult = (void *)result;
46572   return jresult;
46573 }
46574
46575
46576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46577   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46578
46579   arg1 = (Dali::ResourceImage *)jarg1;
46580   {
46581     try {
46582       delete arg1;
46583     } catch (std::out_of_range& e) {
46584       {
46585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46586       };
46587     } catch (std::exception& e) {
46588       {
46589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46590       };
46591     } catch (Dali::DaliException e) {
46592       {
46593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46594       };
46595     } catch (...) {
46596       {
46597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46598       };
46599     }
46600   }
46601
46602 }
46603
46604
46605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46606   void * jresult ;
46607   Dali::ResourceImage *arg1 = 0 ;
46608   Dali::ResourceImage *result = 0 ;
46609
46610   arg1 = (Dali::ResourceImage *)jarg1;
46611   if (!arg1) {
46612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46613     return 0;
46614   }
46615   {
46616     try {
46617       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46618     } catch (std::out_of_range& e) {
46619       {
46620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46621       };
46622     } catch (std::exception& e) {
46623       {
46624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46625       };
46626     } catch (Dali::DaliException e) {
46627       {
46628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46629       };
46630     } catch (...) {
46631       {
46632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46633       };
46634     }
46635   }
46636
46637   jresult = (void *)result;
46638   return jresult;
46639 }
46640
46641
46642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46643   void * jresult ;
46644   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46645   Dali::ResourceImage *arg2 = 0 ;
46646   Dali::ResourceImage *result = 0 ;
46647
46648   arg1 = (Dali::ResourceImage *)jarg1;
46649   arg2 = (Dali::ResourceImage *)jarg2;
46650   if (!arg2) {
46651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46652     return 0;
46653   }
46654   {
46655     try {
46656       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46657     } catch (std::out_of_range& e) {
46658       {
46659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46660       };
46661     } catch (std::exception& e) {
46662       {
46663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46664       };
46665     } catch (Dali::DaliException e) {
46666       {
46667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46668       };
46669     } catch (...) {
46670       {
46671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46672       };
46673     }
46674   }
46675
46676   jresult = (void *)result;
46677   return jresult;
46678 }
46679
46680
46681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46682   void * jresult ;
46683   std::string *arg1 = 0 ;
46684   bool arg2 ;
46685   Dali::ResourceImage result;
46686
46687   if (!jarg1) {
46688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46689     return 0;
46690   }
46691   std::string arg1_str(jarg1);
46692   arg1 = &arg1_str;
46693   arg2 = jarg2 ? true : false;
46694   {
46695     try {
46696       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46697     } catch (std::out_of_range& e) {
46698       {
46699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46700       };
46701     } catch (std::exception& e) {
46702       {
46703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46704       };
46705     } catch (Dali::DaliException e) {
46706       {
46707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46708       };
46709     } catch (...) {
46710       {
46711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46712       };
46713     }
46714   }
46715
46716   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46717
46718   //argout typemap for const std::string&
46719
46720   return jresult;
46721 }
46722
46723
46724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46725   void * jresult ;
46726   std::string *arg1 = 0 ;
46727   Dali::ResourceImage result;
46728
46729   if (!jarg1) {
46730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46731     return 0;
46732   }
46733   std::string arg1_str(jarg1);
46734   arg1 = &arg1_str;
46735   {
46736     try {
46737       result = Dali::ResourceImage::New((std::string const &)*arg1);
46738     } catch (std::out_of_range& e) {
46739       {
46740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46741       };
46742     } catch (std::exception& e) {
46743       {
46744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46745       };
46746     } catch (Dali::DaliException e) {
46747       {
46748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46749       };
46750     } catch (...) {
46751       {
46752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46753       };
46754     }
46755   }
46756
46757   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46758
46759   //argout typemap for const std::string&
46760
46761   return jresult;
46762 }
46763
46764
46765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46766   void * jresult ;
46767   std::string *arg1 = 0 ;
46768   Dali::ImageDimensions arg2 ;
46769   Dali::FittingMode::Type arg3 ;
46770   Dali::SamplingMode::Type arg4 ;
46771   bool arg5 ;
46772   Dali::ImageDimensions *argp2 ;
46773   Dali::ResourceImage result;
46774
46775   if (!jarg1) {
46776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46777     return 0;
46778   }
46779   std::string arg1_str(jarg1);
46780   arg1 = &arg1_str;
46781   argp2 = (Dali::ImageDimensions *)jarg2;
46782   if (!argp2) {
46783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46784     return 0;
46785   }
46786   arg2 = *argp2;
46787   arg3 = (Dali::FittingMode::Type)jarg3;
46788   arg4 = (Dali::SamplingMode::Type)jarg4;
46789   arg5 = jarg5 ? true : false;
46790   {
46791     try {
46792       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46793     } catch (std::out_of_range& e) {
46794       {
46795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46796       };
46797     } catch (std::exception& e) {
46798       {
46799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46800       };
46801     } catch (Dali::DaliException e) {
46802       {
46803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46804       };
46805     } catch (...) {
46806       {
46807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46808       };
46809     }
46810   }
46811
46812   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46813
46814   //argout typemap for const std::string&
46815
46816   return jresult;
46817 }
46818
46819
46820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46821   void * jresult ;
46822   std::string *arg1 = 0 ;
46823   Dali::ImageDimensions arg2 ;
46824   Dali::FittingMode::Type arg3 ;
46825   Dali::SamplingMode::Type arg4 ;
46826   Dali::ImageDimensions *argp2 ;
46827   Dali::ResourceImage result;
46828
46829   if (!jarg1) {
46830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46831     return 0;
46832   }
46833   std::string arg1_str(jarg1);
46834   arg1 = &arg1_str;
46835   argp2 = (Dali::ImageDimensions *)jarg2;
46836   if (!argp2) {
46837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46838     return 0;
46839   }
46840   arg2 = *argp2;
46841   arg3 = (Dali::FittingMode::Type)jarg3;
46842   arg4 = (Dali::SamplingMode::Type)jarg4;
46843   {
46844     try {
46845       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46846     } catch (std::out_of_range& e) {
46847       {
46848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46849       };
46850     } catch (std::exception& e) {
46851       {
46852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46853       };
46854     } catch (Dali::DaliException e) {
46855       {
46856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46857       };
46858     } catch (...) {
46859       {
46860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46861       };
46862     }
46863   }
46864
46865   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46866
46867   //argout typemap for const std::string&
46868
46869   return jresult;
46870 }
46871
46872
46873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46874   void * jresult ;
46875   std::string *arg1 = 0 ;
46876   Dali::ImageDimensions arg2 ;
46877   Dali::FittingMode::Type arg3 ;
46878   Dali::ImageDimensions *argp2 ;
46879   Dali::ResourceImage result;
46880
46881   if (!jarg1) {
46882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46883     return 0;
46884   }
46885   std::string arg1_str(jarg1);
46886   arg1 = &arg1_str;
46887   argp2 = (Dali::ImageDimensions *)jarg2;
46888   if (!argp2) {
46889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46890     return 0;
46891   }
46892   arg2 = *argp2;
46893   arg3 = (Dali::FittingMode::Type)jarg3;
46894   {
46895     try {
46896       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46897     } catch (std::out_of_range& e) {
46898       {
46899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46900       };
46901     } catch (std::exception& e) {
46902       {
46903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46904       };
46905     } catch (Dali::DaliException e) {
46906       {
46907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46908       };
46909     } catch (...) {
46910       {
46911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46912       };
46913     }
46914   }
46915
46916   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46917
46918   //argout typemap for const std::string&
46919
46920   return jresult;
46921 }
46922
46923
46924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46925   void * jresult ;
46926   std::string *arg1 = 0 ;
46927   Dali::ImageDimensions arg2 ;
46928   Dali::ImageDimensions *argp2 ;
46929   Dali::ResourceImage result;
46930
46931   if (!jarg1) {
46932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46933     return 0;
46934   }
46935   std::string arg1_str(jarg1);
46936   arg1 = &arg1_str;
46937   argp2 = (Dali::ImageDimensions *)jarg2;
46938   if (!argp2) {
46939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46940     return 0;
46941   }
46942   arg2 = *argp2;
46943   {
46944     try {
46945       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46946     } catch (std::out_of_range& e) {
46947       {
46948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46949       };
46950     } catch (std::exception& e) {
46951       {
46952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46953       };
46954     } catch (Dali::DaliException e) {
46955       {
46956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46957       };
46958     } catch (...) {
46959       {
46960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46961       };
46962     }
46963   }
46964
46965   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46966
46967   //argout typemap for const std::string&
46968
46969   return jresult;
46970 }
46971
46972
46973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46974   void * jresult ;
46975   Dali::BaseHandle arg1 ;
46976   Dali::BaseHandle *argp1 ;
46977   Dali::ResourceImage result;
46978
46979   argp1 = (Dali::BaseHandle *)jarg1;
46980   if (!argp1) {
46981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46982     return 0;
46983   }
46984   arg1 = *argp1;
46985   {
46986     try {
46987       result = Dali::ResourceImage::DownCast(arg1);
46988     } catch (std::out_of_range& e) {
46989       {
46990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46991       };
46992     } catch (std::exception& e) {
46993       {
46994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46995       };
46996     } catch (Dali::DaliException e) {
46997       {
46998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46999       };
47000     } catch (...) {
47001       {
47002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47003       };
47004     }
47005   }
47006
47007   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47008   return jresult;
47009 }
47010
47011
47012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47013   int jresult ;
47014   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47015   Dali::LoadingState result;
47016
47017   arg1 = (Dali::ResourceImage *)jarg1;
47018   {
47019     try {
47020       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47021     } catch (std::out_of_range& e) {
47022       {
47023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47024       };
47025     } catch (std::exception& e) {
47026       {
47027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47028       };
47029     } catch (Dali::DaliException e) {
47030       {
47031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47032       };
47033     } catch (...) {
47034       {
47035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47036       };
47037     }
47038   }
47039
47040   jresult = (int)result;
47041   return jresult;
47042 }
47043
47044
47045 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47046   char * jresult ;
47047   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47048   std::string result;
47049
47050   arg1 = (Dali::ResourceImage *)jarg1;
47051   {
47052     try {
47053       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47054     } catch (std::out_of_range& e) {
47055       {
47056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47057       };
47058     } catch (std::exception& e) {
47059       {
47060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47061       };
47062     } catch (Dali::DaliException e) {
47063       {
47064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47065       };
47066     } catch (...) {
47067       {
47068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47069       };
47070     }
47071   }
47072
47073   jresult = SWIG_csharp_string_callback((&result)->c_str());
47074   return jresult;
47075 }
47076
47077
47078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47079   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47080
47081   arg1 = (Dali::ResourceImage *)jarg1;
47082   {
47083     try {
47084       (arg1)->Reload();
47085     } catch (std::out_of_range& e) {
47086       {
47087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47088       };
47089     } catch (std::exception& e) {
47090       {
47091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47092       };
47093     } catch (Dali::DaliException e) {
47094       {
47095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47096       };
47097     } catch (...) {
47098       {
47099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47100       };
47101     }
47102   }
47103
47104 }
47105
47106
47107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47108   void * jresult ;
47109   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47110   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47111
47112   arg1 = (Dali::ResourceImage *)jarg1;
47113   {
47114     try {
47115       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47116     } catch (std::out_of_range& e) {
47117       {
47118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47119       };
47120     } catch (std::exception& e) {
47121       {
47122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47123       };
47124     } catch (Dali::DaliException e) {
47125       {
47126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47127       };
47128     } catch (...) {
47129       {
47130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47131       };
47132     }
47133   }
47134
47135   jresult = (void *)result;
47136   return jresult;
47137 }
47138
47139
47140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47141   void * jresult ;
47142   Dali::FrameBufferImage *result = 0 ;
47143
47144   {
47145     try {
47146       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47147     } catch (std::out_of_range& e) {
47148       {
47149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47150       };
47151     } catch (std::exception& e) {
47152       {
47153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47154       };
47155     } catch (Dali::DaliException e) {
47156       {
47157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47158       };
47159     } catch (...) {
47160       {
47161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47162       };
47163     }
47164   }
47165
47166   jresult = (void *)result;
47167   return jresult;
47168 }
47169
47170
47171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47172   void * jresult ;
47173   unsigned int arg1 ;
47174   unsigned int arg2 ;
47175   Dali::Pixel::Format arg3 ;
47176   Dali::RenderBuffer::Format arg4 ;
47177   Dali::FrameBufferImage result;
47178
47179   arg1 = (unsigned int)jarg1;
47180   arg2 = (unsigned int)jarg2;
47181   arg3 = (Dali::Pixel::Format)jarg3;
47182   arg4 = (Dali::RenderBuffer::Format)jarg4;
47183   {
47184     try {
47185       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47186     } catch (std::out_of_range& e) {
47187       {
47188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47189       };
47190     } catch (std::exception& e) {
47191       {
47192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47193       };
47194     } catch (Dali::DaliException e) {
47195       {
47196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47197       };
47198     } catch (...) {
47199       {
47200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47201       };
47202     }
47203   }
47204
47205   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47206   return jresult;
47207 }
47208
47209
47210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47211   void * jresult ;
47212   unsigned int arg1 ;
47213   unsigned int arg2 ;
47214   Dali::Pixel::Format arg3 ;
47215   Dali::FrameBufferImage result;
47216
47217   arg1 = (unsigned int)jarg1;
47218   arg2 = (unsigned int)jarg2;
47219   arg3 = (Dali::Pixel::Format)jarg3;
47220   {
47221     try {
47222       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47223     } catch (std::out_of_range& e) {
47224       {
47225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47226       };
47227     } catch (std::exception& e) {
47228       {
47229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47230       };
47231     } catch (Dali::DaliException e) {
47232       {
47233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47234       };
47235     } catch (...) {
47236       {
47237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47238       };
47239     }
47240   }
47241
47242   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47243   return jresult;
47244 }
47245
47246
47247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47248   void * jresult ;
47249   unsigned int arg1 ;
47250   unsigned int arg2 ;
47251   Dali::FrameBufferImage result;
47252
47253   arg1 = (unsigned int)jarg1;
47254   arg2 = (unsigned int)jarg2;
47255   {
47256     try {
47257       result = Dali::FrameBufferImage::New(arg1,arg2);
47258     } catch (std::out_of_range& e) {
47259       {
47260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47261       };
47262     } catch (std::exception& e) {
47263       {
47264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47265       };
47266     } catch (Dali::DaliException e) {
47267       {
47268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47269       };
47270     } catch (...) {
47271       {
47272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47273       };
47274     }
47275   }
47276
47277   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47278   return jresult;
47279 }
47280
47281
47282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47283   void * jresult ;
47284   unsigned int arg1 ;
47285   Dali::FrameBufferImage result;
47286
47287   arg1 = (unsigned int)jarg1;
47288   {
47289     try {
47290       result = Dali::FrameBufferImage::New(arg1);
47291     } catch (std::out_of_range& e) {
47292       {
47293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47294       };
47295     } catch (std::exception& e) {
47296       {
47297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47298       };
47299     } catch (Dali::DaliException e) {
47300       {
47301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47302       };
47303     } catch (...) {
47304       {
47305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47306       };
47307     }
47308   }
47309
47310   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47311   return jresult;
47312 }
47313
47314
47315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47316   void * jresult ;
47317   Dali::FrameBufferImage result;
47318
47319   {
47320     try {
47321       result = Dali::FrameBufferImage::New();
47322     } catch (std::out_of_range& e) {
47323       {
47324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47325       };
47326     } catch (std::exception& e) {
47327       {
47328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47329       };
47330     } catch (Dali::DaliException e) {
47331       {
47332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47333       };
47334     } catch (...) {
47335       {
47336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47337       };
47338     }
47339   }
47340
47341   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47342   return jresult;
47343 }
47344
47345
47346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47347   void * jresult ;
47348   Dali::NativeImageInterface *arg1 = 0 ;
47349   Dali::FrameBufferImage result;
47350
47351   arg1 = (Dali::NativeImageInterface *)jarg1;
47352   if (!arg1) {
47353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47354     return 0;
47355   }
47356   {
47357     try {
47358       result = Dali::FrameBufferImage::New(*arg1);
47359     } catch (std::out_of_range& e) {
47360       {
47361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47362       };
47363     } catch (std::exception& e) {
47364       {
47365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47366       };
47367     } catch (Dali::DaliException e) {
47368       {
47369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47370       };
47371     } catch (...) {
47372       {
47373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47374       };
47375     }
47376   }
47377
47378   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47379   return jresult;
47380 }
47381
47382
47383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47384   void * jresult ;
47385   Dali::BaseHandle arg1 ;
47386   Dali::BaseHandle *argp1 ;
47387   Dali::FrameBufferImage result;
47388
47389   argp1 = (Dali::BaseHandle *)jarg1;
47390   if (!argp1) {
47391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47392     return 0;
47393   }
47394   arg1 = *argp1;
47395   {
47396     try {
47397       result = Dali::FrameBufferImage::DownCast(arg1);
47398     } catch (std::out_of_range& e) {
47399       {
47400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47401       };
47402     } catch (std::exception& e) {
47403       {
47404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47405       };
47406     } catch (Dali::DaliException e) {
47407       {
47408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47409       };
47410     } catch (...) {
47411       {
47412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47413       };
47414     }
47415   }
47416
47417   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47418   return jresult;
47419 }
47420
47421
47422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47423   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47424
47425   arg1 = (Dali::FrameBufferImage *)jarg1;
47426   {
47427     try {
47428       delete arg1;
47429     } catch (std::out_of_range& e) {
47430       {
47431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47432       };
47433     } catch (std::exception& e) {
47434       {
47435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47436       };
47437     } catch (Dali::DaliException e) {
47438       {
47439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47440       };
47441     } catch (...) {
47442       {
47443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47444       };
47445     }
47446   }
47447
47448 }
47449
47450
47451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47452   void * jresult ;
47453   Dali::FrameBufferImage *arg1 = 0 ;
47454   Dali::FrameBufferImage *result = 0 ;
47455
47456   arg1 = (Dali::FrameBufferImage *)jarg1;
47457   if (!arg1) {
47458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47459     return 0;
47460   }
47461   {
47462     try {
47463       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47464     } catch (std::out_of_range& e) {
47465       {
47466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47467       };
47468     } catch (std::exception& e) {
47469       {
47470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47471       };
47472     } catch (Dali::DaliException e) {
47473       {
47474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47475       };
47476     } catch (...) {
47477       {
47478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47479       };
47480     }
47481   }
47482
47483   jresult = (void *)result;
47484   return jresult;
47485 }
47486
47487
47488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47489   void * jresult ;
47490   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47491   Dali::FrameBufferImage *arg2 = 0 ;
47492   Dali::FrameBufferImage *result = 0 ;
47493
47494   arg1 = (Dali::FrameBufferImage *)jarg1;
47495   arg2 = (Dali::FrameBufferImage *)jarg2;
47496   if (!arg2) {
47497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47498     return 0;
47499   }
47500   {
47501     try {
47502       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47503     } catch (std::out_of_range& e) {
47504       {
47505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47506       };
47507     } catch (std::exception& e) {
47508       {
47509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47510       };
47511     } catch (Dali::DaliException e) {
47512       {
47513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47514       };
47515     } catch (...) {
47516       {
47517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47518       };
47519     }
47520   }
47521
47522   jresult = (void *)result;
47523   return jresult;
47524 }
47525
47526
47527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47528   void * jresult ;
47529   Dali::NinePatchImage *result = 0 ;
47530
47531   {
47532     try {
47533       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47534     } catch (std::out_of_range& e) {
47535       {
47536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47537       };
47538     } catch (std::exception& e) {
47539       {
47540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47541       };
47542     } catch (Dali::DaliException e) {
47543       {
47544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47545       };
47546     } catch (...) {
47547       {
47548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47549       };
47550     }
47551   }
47552
47553   jresult = (void *)result;
47554   return jresult;
47555 }
47556
47557
47558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47559   void * jresult ;
47560   std::string *arg1 = 0 ;
47561   Dali::NinePatchImage result;
47562
47563   if (!jarg1) {
47564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47565     return 0;
47566   }
47567   std::string arg1_str(jarg1);
47568   arg1 = &arg1_str;
47569   {
47570     try {
47571       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47572     } catch (std::out_of_range& e) {
47573       {
47574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47575       };
47576     } catch (std::exception& e) {
47577       {
47578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47579       };
47580     } catch (Dali::DaliException e) {
47581       {
47582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47583       };
47584     } catch (...) {
47585       {
47586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47587       };
47588     }
47589   }
47590
47591   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47592
47593   //argout typemap for const std::string&
47594
47595   return jresult;
47596 }
47597
47598
47599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47600   void * jresult ;
47601   Dali::BaseHandle arg1 ;
47602   Dali::BaseHandle *argp1 ;
47603   Dali::NinePatchImage result;
47604
47605   argp1 = (Dali::BaseHandle *)jarg1;
47606   if (!argp1) {
47607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47608     return 0;
47609   }
47610   arg1 = *argp1;
47611   {
47612     try {
47613       result = Dali::NinePatchImage::DownCast(arg1);
47614     } catch (std::out_of_range& e) {
47615       {
47616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47617       };
47618     } catch (std::exception& e) {
47619       {
47620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47621       };
47622     } catch (Dali::DaliException e) {
47623       {
47624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47625       };
47626     } catch (...) {
47627       {
47628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47629       };
47630     }
47631   }
47632
47633   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47634   return jresult;
47635 }
47636
47637
47638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47639   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47640
47641   arg1 = (Dali::NinePatchImage *)jarg1;
47642   {
47643     try {
47644       delete arg1;
47645     } catch (std::out_of_range& e) {
47646       {
47647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47648       };
47649     } catch (std::exception& e) {
47650       {
47651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47652       };
47653     } catch (Dali::DaliException e) {
47654       {
47655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47656       };
47657     } catch (...) {
47658       {
47659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47660       };
47661     }
47662   }
47663
47664 }
47665
47666
47667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47668   void * jresult ;
47669   Dali::NinePatchImage *arg1 = 0 ;
47670   Dali::NinePatchImage *result = 0 ;
47671
47672   arg1 = (Dali::NinePatchImage *)jarg1;
47673   if (!arg1) {
47674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47675     return 0;
47676   }
47677   {
47678     try {
47679       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47680     } catch (std::out_of_range& e) {
47681       {
47682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47683       };
47684     } catch (std::exception& e) {
47685       {
47686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47687       };
47688     } catch (Dali::DaliException e) {
47689       {
47690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47691       };
47692     } catch (...) {
47693       {
47694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47695       };
47696     }
47697   }
47698
47699   jresult = (void *)result;
47700   return jresult;
47701 }
47702
47703
47704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47705   void * jresult ;
47706   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47707   Dali::NinePatchImage *arg2 = 0 ;
47708   Dali::NinePatchImage *result = 0 ;
47709
47710   arg1 = (Dali::NinePatchImage *)jarg1;
47711   arg2 = (Dali::NinePatchImage *)jarg2;
47712   if (!arg2) {
47713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47714     return 0;
47715   }
47716   {
47717     try {
47718       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47719     } catch (std::out_of_range& e) {
47720       {
47721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47722       };
47723     } catch (std::exception& e) {
47724       {
47725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47726       };
47727     } catch (Dali::DaliException e) {
47728       {
47729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47730       };
47731     } catch (...) {
47732       {
47733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47734       };
47735     }
47736   }
47737
47738   jresult = (void *)result;
47739   return jresult;
47740 }
47741
47742
47743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47744   void * jresult ;
47745   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47746   Dali::Vector4 result;
47747
47748   arg1 = (Dali::NinePatchImage *)jarg1;
47749   {
47750     try {
47751       result = (arg1)->GetStretchBorders();
47752     } catch (std::out_of_range& e) {
47753       {
47754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47755       };
47756     } catch (std::exception& e) {
47757       {
47758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47759       };
47760     } catch (Dali::DaliException e) {
47761       {
47762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47763       };
47764     } catch (...) {
47765       {
47766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47767       };
47768     }
47769   }
47770
47771   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47772   return jresult;
47773 }
47774
47775
47776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47777   void * jresult ;
47778   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47779   Dali::NinePatchImage::StretchRanges *result = 0 ;
47780
47781   arg1 = (Dali::NinePatchImage *)jarg1;
47782   {
47783     try {
47784       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47785     } catch (std::out_of_range& e) {
47786       {
47787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47788       };
47789     } catch (std::exception& e) {
47790       {
47791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47792       };
47793     } catch (Dali::DaliException e) {
47794       {
47795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47796       };
47797     } catch (...) {
47798       {
47799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47800       };
47801     }
47802   }
47803
47804   jresult = (void *)result;
47805   return jresult;
47806 }
47807
47808
47809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47810   void * jresult ;
47811   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47812   Dali::NinePatchImage::StretchRanges *result = 0 ;
47813
47814   arg1 = (Dali::NinePatchImage *)jarg1;
47815   {
47816     try {
47817       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47818     } catch (std::out_of_range& e) {
47819       {
47820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47821       };
47822     } catch (std::exception& e) {
47823       {
47824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47825       };
47826     } catch (Dali::DaliException e) {
47827       {
47828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47829       };
47830     } catch (...) {
47831       {
47832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47833       };
47834     }
47835   }
47836
47837   jresult = (void *)result;
47838   return jresult;
47839 }
47840
47841
47842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47843   void * jresult ;
47844   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47845   Dali::Rect< int > result;
47846
47847   arg1 = (Dali::NinePatchImage *)jarg1;
47848   {
47849     try {
47850       result = (arg1)->GetChildRectangle();
47851     } catch (std::out_of_range& e) {
47852       {
47853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47854       };
47855     } catch (std::exception& e) {
47856       {
47857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47858       };
47859     } catch (Dali::DaliException e) {
47860       {
47861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47862       };
47863     } catch (...) {
47864       {
47865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47866       };
47867     }
47868   }
47869
47870   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47871   return jresult;
47872 }
47873
47874
47875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47876   void * jresult ;
47877   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47878   Dali::BufferImage result;
47879
47880   arg1 = (Dali::NinePatchImage *)jarg1;
47881   {
47882     try {
47883       result = (arg1)->CreateCroppedBufferImage();
47884     } catch (std::out_of_range& e) {
47885       {
47886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47887       };
47888     } catch (std::exception& e) {
47889       {
47890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47891       };
47892     } catch (Dali::DaliException e) {
47893       {
47894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47895       };
47896     } catch (...) {
47897       {
47898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47899       };
47900     }
47901   }
47902
47903   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47904   return jresult;
47905 }
47906
47907
47908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47909   unsigned int jresult ;
47910   std::string *arg1 = 0 ;
47911   bool result;
47912
47913   if (!jarg1) {
47914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47915     return 0;
47916   }
47917   std::string arg1_str(jarg1);
47918   arg1 = &arg1_str;
47919   {
47920     try {
47921       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47922     } catch (std::out_of_range& e) {
47923       {
47924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47925       };
47926     } catch (std::exception& e) {
47927       {
47928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47929       };
47930     } catch (Dali::DaliException e) {
47931       {
47932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47933       };
47934     } catch (...) {
47935       {
47936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47937       };
47938     }
47939   }
47940
47941   jresult = result;
47942
47943   //argout typemap for const std::string&
47944
47945   return jresult;
47946 }
47947
47948
47949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47950   int jresult ;
47951   int result;
47952
47953   result = (int)Dali::CameraActor::Property::TYPE;
47954   jresult = (int)result;
47955   return jresult;
47956 }
47957
47958
47959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47960   int jresult ;
47961   int result;
47962
47963   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47964   jresult = (int)result;
47965   return jresult;
47966 }
47967
47968
47969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47970   int jresult ;
47971   int result;
47972
47973   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47974   jresult = (int)result;
47975   return jresult;
47976 }
47977
47978
47979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47980   int jresult ;
47981   int result;
47982
47983   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47984   jresult = (int)result;
47985   return jresult;
47986 }
47987
47988
47989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47990   int jresult ;
47991   int result;
47992
47993   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47994   jresult = (int)result;
47995   return jresult;
47996 }
47997
47998
47999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48000   int jresult ;
48001   int result;
48002
48003   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48004   jresult = (int)result;
48005   return jresult;
48006 }
48007
48008
48009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48010   int jresult ;
48011   int result;
48012
48013   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48014   jresult = (int)result;
48015   return jresult;
48016 }
48017
48018
48019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48020   int jresult ;
48021   int result;
48022
48023   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48024   jresult = (int)result;
48025   return jresult;
48026 }
48027
48028
48029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48030   int jresult ;
48031   int result;
48032
48033   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48034   jresult = (int)result;
48035   return jresult;
48036 }
48037
48038
48039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48040   int jresult ;
48041   int result;
48042
48043   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48044   jresult = (int)result;
48045   return jresult;
48046 }
48047
48048
48049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48050   int jresult ;
48051   int result;
48052
48053   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48054   jresult = (int)result;
48055   return jresult;
48056 }
48057
48058
48059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48060   int jresult ;
48061   int result;
48062
48063   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48064   jresult = (int)result;
48065   return jresult;
48066 }
48067
48068
48069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48070   int jresult ;
48071   int result;
48072
48073   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48074   jresult = (int)result;
48075   return jresult;
48076 }
48077
48078
48079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48080   int jresult ;
48081   int result;
48082
48083   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48084   jresult = (int)result;
48085   return jresult;
48086 }
48087
48088
48089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48090   void * jresult ;
48091   Dali::CameraActor::Property *result = 0 ;
48092
48093   {
48094     try {
48095       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48096     } catch (std::out_of_range& e) {
48097       {
48098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48099       };
48100     } catch (std::exception& e) {
48101       {
48102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48103       };
48104     } catch (Dali::DaliException e) {
48105       {
48106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48107       };
48108     } catch (...) {
48109       {
48110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48111       };
48112     }
48113   }
48114
48115   jresult = (void *)result;
48116   return jresult;
48117 }
48118
48119
48120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48121   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48122
48123   arg1 = (Dali::CameraActor::Property *)jarg1;
48124   {
48125     try {
48126       delete arg1;
48127     } catch (std::out_of_range& e) {
48128       {
48129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48130       };
48131     } catch (std::exception& e) {
48132       {
48133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48134       };
48135     } catch (Dali::DaliException e) {
48136       {
48137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48138       };
48139     } catch (...) {
48140       {
48141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48142       };
48143     }
48144   }
48145
48146 }
48147
48148
48149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48150   void * jresult ;
48151   Dali::CameraActor *result = 0 ;
48152
48153   {
48154     try {
48155       result = (Dali::CameraActor *)new Dali::CameraActor();
48156     } catch (std::out_of_range& e) {
48157       {
48158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48159       };
48160     } catch (std::exception& e) {
48161       {
48162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48163       };
48164     } catch (Dali::DaliException e) {
48165       {
48166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48167       };
48168     } catch (...) {
48169       {
48170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48171       };
48172     }
48173   }
48174
48175   jresult = (void *)result;
48176   return jresult;
48177 }
48178
48179
48180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48181   void * jresult ;
48182   Dali::CameraActor result;
48183
48184   {
48185     try {
48186       result = Dali::CameraActor::New();
48187     } catch (std::out_of_range& e) {
48188       {
48189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48190       };
48191     } catch (std::exception& e) {
48192       {
48193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48194       };
48195     } catch (Dali::DaliException e) {
48196       {
48197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48198       };
48199     } catch (...) {
48200       {
48201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48202       };
48203     }
48204   }
48205
48206   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48207   return jresult;
48208 }
48209
48210
48211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48212   void * jresult ;
48213   Dali::Size *arg1 = 0 ;
48214   Dali::CameraActor result;
48215
48216   arg1 = (Dali::Size *)jarg1;
48217   if (!arg1) {
48218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48219     return 0;
48220   }
48221   {
48222     try {
48223       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48224     } catch (std::out_of_range& e) {
48225       {
48226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48227       };
48228     } catch (std::exception& e) {
48229       {
48230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48231       };
48232     } catch (Dali::DaliException e) {
48233       {
48234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48235       };
48236     } catch (...) {
48237       {
48238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48239       };
48240     }
48241   }
48242
48243   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48244   return jresult;
48245 }
48246
48247
48248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48249   void * jresult ;
48250   Dali::BaseHandle arg1 ;
48251   Dali::BaseHandle *argp1 ;
48252   Dali::CameraActor result;
48253
48254   argp1 = (Dali::BaseHandle *)jarg1;
48255   if (!argp1) {
48256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48257     return 0;
48258   }
48259   arg1 = *argp1;
48260   {
48261     try {
48262       result = Dali::CameraActor::DownCast(arg1);
48263     } catch (std::out_of_range& e) {
48264       {
48265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48266       };
48267     } catch (std::exception& e) {
48268       {
48269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48270       };
48271     } catch (Dali::DaliException e) {
48272       {
48273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48274       };
48275     } catch (...) {
48276       {
48277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48278       };
48279     }
48280   }
48281
48282   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48283   return jresult;
48284 }
48285
48286
48287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48288   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48289
48290   arg1 = (Dali::CameraActor *)jarg1;
48291   {
48292     try {
48293       delete arg1;
48294     } catch (std::out_of_range& e) {
48295       {
48296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48297       };
48298     } catch (std::exception& e) {
48299       {
48300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48301       };
48302     } catch (Dali::DaliException e) {
48303       {
48304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48305       };
48306     } catch (...) {
48307       {
48308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48309       };
48310     }
48311   }
48312
48313 }
48314
48315
48316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48317   void * jresult ;
48318   Dali::CameraActor *arg1 = 0 ;
48319   Dali::CameraActor *result = 0 ;
48320
48321   arg1 = (Dali::CameraActor *)jarg1;
48322   if (!arg1) {
48323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48324     return 0;
48325   }
48326   {
48327     try {
48328       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48329     } catch (std::out_of_range& e) {
48330       {
48331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48332       };
48333     } catch (std::exception& e) {
48334       {
48335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48336       };
48337     } catch (Dali::DaliException e) {
48338       {
48339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48340       };
48341     } catch (...) {
48342       {
48343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48344       };
48345     }
48346   }
48347
48348   jresult = (void *)result;
48349   return jresult;
48350 }
48351
48352
48353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48354   void * jresult ;
48355   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48356   Dali::CameraActor *arg2 = 0 ;
48357   Dali::CameraActor *result = 0 ;
48358
48359   arg1 = (Dali::CameraActor *)jarg1;
48360   arg2 = (Dali::CameraActor *)jarg2;
48361   if (!arg2) {
48362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48363     return 0;
48364   }
48365   {
48366     try {
48367       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48368     } catch (std::out_of_range& e) {
48369       {
48370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48371       };
48372     } catch (std::exception& e) {
48373       {
48374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48375       };
48376     } catch (Dali::DaliException e) {
48377       {
48378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48379       };
48380     } catch (...) {
48381       {
48382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48383       };
48384     }
48385   }
48386
48387   jresult = (void *)result;
48388   return jresult;
48389 }
48390
48391
48392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48393   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48394   Dali::Camera::Type arg2 ;
48395
48396   arg1 = (Dali::CameraActor *)jarg1;
48397   arg2 = (Dali::Camera::Type)jarg2;
48398   {
48399     try {
48400       (arg1)->SetType(arg2);
48401     } catch (std::out_of_range& e) {
48402       {
48403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48404       };
48405     } catch (std::exception& e) {
48406       {
48407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48408       };
48409     } catch (Dali::DaliException e) {
48410       {
48411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48412       };
48413     } catch (...) {
48414       {
48415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48416       };
48417     }
48418   }
48419
48420 }
48421
48422
48423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48424   int jresult ;
48425   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48426   Dali::Camera::Type result;
48427
48428   arg1 = (Dali::CameraActor *)jarg1;
48429   {
48430     try {
48431       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48432     } catch (std::out_of_range& e) {
48433       {
48434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48435       };
48436     } catch (std::exception& e) {
48437       {
48438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48439       };
48440     } catch (Dali::DaliException e) {
48441       {
48442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48443       };
48444     } catch (...) {
48445       {
48446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48447       };
48448     }
48449   }
48450
48451   jresult = (int)result;
48452   return jresult;
48453 }
48454
48455
48456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48457   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48458   Dali::Camera::ProjectionMode arg2 ;
48459
48460   arg1 = (Dali::CameraActor *)jarg1;
48461   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48462   {
48463     try {
48464       (arg1)->SetProjectionMode(arg2);
48465     } catch (std::out_of_range& e) {
48466       {
48467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48468       };
48469     } catch (std::exception& e) {
48470       {
48471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48472       };
48473     } catch (Dali::DaliException e) {
48474       {
48475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48476       };
48477     } catch (...) {
48478       {
48479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48480       };
48481     }
48482   }
48483
48484 }
48485
48486
48487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48488   int jresult ;
48489   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48490   Dali::Camera::ProjectionMode result;
48491
48492   arg1 = (Dali::CameraActor *)jarg1;
48493   {
48494     try {
48495       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48496     } catch (std::out_of_range& e) {
48497       {
48498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48499       };
48500     } catch (std::exception& e) {
48501       {
48502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48503       };
48504     } catch (Dali::DaliException e) {
48505       {
48506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48507       };
48508     } catch (...) {
48509       {
48510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48511       };
48512     }
48513   }
48514
48515   jresult = (int)result;
48516   return jresult;
48517 }
48518
48519
48520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48521   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48522   float arg2 ;
48523
48524   arg1 = (Dali::CameraActor *)jarg1;
48525   arg2 = (float)jarg2;
48526   {
48527     try {
48528       (arg1)->SetFieldOfView(arg2);
48529     } catch (std::out_of_range& e) {
48530       {
48531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48532       };
48533     } catch (std::exception& e) {
48534       {
48535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48536       };
48537     } catch (Dali::DaliException e) {
48538       {
48539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48540       };
48541     } catch (...) {
48542       {
48543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48544       };
48545     }
48546   }
48547
48548 }
48549
48550
48551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48552   float jresult ;
48553   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48554   float result;
48555
48556   arg1 = (Dali::CameraActor *)jarg1;
48557   {
48558     try {
48559       result = (float)(arg1)->GetFieldOfView();
48560     } catch (std::out_of_range& e) {
48561       {
48562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48563       };
48564     } catch (std::exception& e) {
48565       {
48566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48567       };
48568     } catch (Dali::DaliException e) {
48569       {
48570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48571       };
48572     } catch (...) {
48573       {
48574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48575       };
48576     }
48577   }
48578
48579   jresult = result;
48580   return jresult;
48581 }
48582
48583
48584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48585   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48586   float arg2 ;
48587
48588   arg1 = (Dali::CameraActor *)jarg1;
48589   arg2 = (float)jarg2;
48590   {
48591     try {
48592       (arg1)->SetAspectRatio(arg2);
48593     } catch (std::out_of_range& e) {
48594       {
48595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48596       };
48597     } catch (std::exception& e) {
48598       {
48599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48600       };
48601     } catch (Dali::DaliException e) {
48602       {
48603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48604       };
48605     } catch (...) {
48606       {
48607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48608       };
48609     }
48610   }
48611
48612 }
48613
48614
48615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48616   float jresult ;
48617   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48618   float result;
48619
48620   arg1 = (Dali::CameraActor *)jarg1;
48621   {
48622     try {
48623       result = (float)(arg1)->GetAspectRatio();
48624     } catch (std::out_of_range& e) {
48625       {
48626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48627       };
48628     } catch (std::exception& e) {
48629       {
48630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48631       };
48632     } catch (Dali::DaliException e) {
48633       {
48634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48635       };
48636     } catch (...) {
48637       {
48638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48639       };
48640     }
48641   }
48642
48643   jresult = result;
48644   return jresult;
48645 }
48646
48647
48648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48649   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48650   float arg2 ;
48651
48652   arg1 = (Dali::CameraActor *)jarg1;
48653   arg2 = (float)jarg2;
48654   {
48655     try {
48656       (arg1)->SetNearClippingPlane(arg2);
48657     } catch (std::out_of_range& e) {
48658       {
48659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48660       };
48661     } catch (std::exception& e) {
48662       {
48663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48664       };
48665     } catch (Dali::DaliException e) {
48666       {
48667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48668       };
48669     } catch (...) {
48670       {
48671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48672       };
48673     }
48674   }
48675
48676 }
48677
48678
48679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48680   float jresult ;
48681   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48682   float result;
48683
48684   arg1 = (Dali::CameraActor *)jarg1;
48685   {
48686     try {
48687       result = (float)(arg1)->GetNearClippingPlane();
48688     } catch (std::out_of_range& e) {
48689       {
48690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48691       };
48692     } catch (std::exception& e) {
48693       {
48694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48695       };
48696     } catch (Dali::DaliException e) {
48697       {
48698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48699       };
48700     } catch (...) {
48701       {
48702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48703       };
48704     }
48705   }
48706
48707   jresult = result;
48708   return jresult;
48709 }
48710
48711
48712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48713   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48714   float arg2 ;
48715
48716   arg1 = (Dali::CameraActor *)jarg1;
48717   arg2 = (float)jarg2;
48718   {
48719     try {
48720       (arg1)->SetFarClippingPlane(arg2);
48721     } catch (std::out_of_range& e) {
48722       {
48723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48724       };
48725     } catch (std::exception& e) {
48726       {
48727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48728       };
48729     } catch (Dali::DaliException e) {
48730       {
48731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48732       };
48733     } catch (...) {
48734       {
48735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48736       };
48737     }
48738   }
48739
48740 }
48741
48742
48743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48744   float jresult ;
48745   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48746   float result;
48747
48748   arg1 = (Dali::CameraActor *)jarg1;
48749   {
48750     try {
48751       result = (float)(arg1)->GetFarClippingPlane();
48752     } catch (std::out_of_range& e) {
48753       {
48754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48755       };
48756     } catch (std::exception& e) {
48757       {
48758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48759       };
48760     } catch (Dali::DaliException e) {
48761       {
48762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48763       };
48764     } catch (...) {
48765       {
48766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48767       };
48768     }
48769   }
48770
48771   jresult = result;
48772   return jresult;
48773 }
48774
48775
48776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48777   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48778   Dali::Vector3 *arg2 = 0 ;
48779
48780   arg1 = (Dali::CameraActor *)jarg1;
48781   arg2 = (Dali::Vector3 *)jarg2;
48782   if (!arg2) {
48783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48784     return ;
48785   }
48786   {
48787     try {
48788       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48789     } catch (std::out_of_range& e) {
48790       {
48791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48792       };
48793     } catch (std::exception& e) {
48794       {
48795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48796       };
48797     } catch (Dali::DaliException e) {
48798       {
48799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48800       };
48801     } catch (...) {
48802       {
48803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48804       };
48805     }
48806   }
48807
48808 }
48809
48810
48811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48812   void * jresult ;
48813   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48814   Dali::Vector3 result;
48815
48816   arg1 = (Dali::CameraActor *)jarg1;
48817   {
48818     try {
48819       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48820     } catch (std::out_of_range& e) {
48821       {
48822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48823       };
48824     } catch (std::exception& e) {
48825       {
48826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48827       };
48828     } catch (Dali::DaliException e) {
48829       {
48830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48831       };
48832     } catch (...) {
48833       {
48834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48835       };
48836     }
48837   }
48838
48839   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48840   return jresult;
48841 }
48842
48843
48844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48845   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48846   bool arg2 ;
48847
48848   arg1 = (Dali::CameraActor *)jarg1;
48849   arg2 = jarg2 ? true : false;
48850   {
48851     try {
48852       (arg1)->SetInvertYAxis(arg2);
48853     } catch (std::out_of_range& e) {
48854       {
48855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48856       };
48857     } catch (std::exception& e) {
48858       {
48859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48860       };
48861     } catch (Dali::DaliException e) {
48862       {
48863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48864       };
48865     } catch (...) {
48866       {
48867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48868       };
48869     }
48870   }
48871
48872 }
48873
48874
48875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48876   unsigned int jresult ;
48877   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48878   bool result;
48879
48880   arg1 = (Dali::CameraActor *)jarg1;
48881   {
48882     try {
48883       result = (bool)(arg1)->GetInvertYAxis();
48884     } catch (std::out_of_range& e) {
48885       {
48886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48887       };
48888     } catch (std::exception& e) {
48889       {
48890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48891       };
48892     } catch (Dali::DaliException e) {
48893       {
48894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48895       };
48896     } catch (...) {
48897       {
48898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48899       };
48900     }
48901   }
48902
48903   jresult = result;
48904   return jresult;
48905 }
48906
48907
48908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48909   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48910   Dali::Size *arg2 = 0 ;
48911
48912   arg1 = (Dali::CameraActor *)jarg1;
48913   arg2 = (Dali::Size *)jarg2;
48914   if (!arg2) {
48915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48916     return ;
48917   }
48918   {
48919     try {
48920       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48921     } catch (std::out_of_range& e) {
48922       {
48923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48924       };
48925     } catch (std::exception& e) {
48926       {
48927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48928       };
48929     } catch (Dali::DaliException e) {
48930       {
48931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48932       };
48933     } catch (...) {
48934       {
48935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48936       };
48937     }
48938   }
48939
48940 }
48941
48942
48943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48944   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48945   Dali::Size *arg2 = 0 ;
48946
48947   arg1 = (Dali::CameraActor *)jarg1;
48948   arg2 = (Dali::Size *)jarg2;
48949   if (!arg2) {
48950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48951     return ;
48952   }
48953   {
48954     try {
48955       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48956     } catch (std::out_of_range& e) {
48957       {
48958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48959       };
48960     } catch (std::exception& e) {
48961       {
48962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48963       };
48964     } catch (Dali::DaliException e) {
48965       {
48966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48967       };
48968     } catch (...) {
48969       {
48970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48971       };
48972     }
48973   }
48974
48975 }
48976
48977
48978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48979   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48980   float arg2 ;
48981   float arg3 ;
48982   float arg4 ;
48983   float arg5 ;
48984   float arg6 ;
48985   float arg7 ;
48986
48987   arg1 = (Dali::CameraActor *)jarg1;
48988   arg2 = (float)jarg2;
48989   arg3 = (float)jarg3;
48990   arg4 = (float)jarg4;
48991   arg5 = (float)jarg5;
48992   arg6 = (float)jarg6;
48993   arg7 = (float)jarg7;
48994   {
48995     try {
48996       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48997     } catch (std::out_of_range& e) {
48998       {
48999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49000       };
49001     } catch (std::exception& e) {
49002       {
49003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49004       };
49005     } catch (Dali::DaliException e) {
49006       {
49007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49008       };
49009     } catch (...) {
49010       {
49011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49012       };
49013     }
49014   }
49015
49016 }
49017
49018
49019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49020   void * jresult ;
49021   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49022
49023   {
49024     try {
49025       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49026     } catch (std::out_of_range& e) {
49027       {
49028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49029       };
49030     } catch (std::exception& e) {
49031       {
49032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49033       };
49034     } catch (Dali::DaliException e) {
49035       {
49036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49037       };
49038     } catch (...) {
49039       {
49040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49041       };
49042     }
49043   }
49044
49045   jresult = (void *)result;
49046   return jresult;
49047 }
49048
49049
49050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49051   void * jresult ;
49052   std::string arg1 ;
49053   Dali::Property::Value arg2 ;
49054   Dali::Property::Value *argp2 ;
49055   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49056
49057   if (!jarg1) {
49058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49059     return 0;
49060   }
49061   (&arg1)->assign(jarg1);
49062   argp2 = (Dali::Property::Value *)jarg2;
49063   if (!argp2) {
49064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49065     return 0;
49066   }
49067   arg2 = *argp2;
49068   {
49069     try {
49070       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49071     } catch (std::out_of_range& e) {
49072       {
49073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49074       };
49075     } catch (std::exception& e) {
49076       {
49077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49078       };
49079     } catch (Dali::DaliException e) {
49080       {
49081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49082       };
49083     } catch (...) {
49084       {
49085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49086       };
49087     }
49088   }
49089
49090   jresult = (void *)result;
49091   return jresult;
49092 }
49093
49094
49095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49096   void * jresult ;
49097   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49098   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49099
49100   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49101   if (!arg1) {
49102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49103     return 0;
49104   }
49105   {
49106     try {
49107       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);
49108     } catch (std::out_of_range& e) {
49109       {
49110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49111       };
49112     } catch (std::exception& e) {
49113       {
49114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49115       };
49116     } catch (Dali::DaliException e) {
49117       {
49118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49119       };
49120     } catch (...) {
49121       {
49122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49123       };
49124     }
49125   }
49126
49127   jresult = (void *)result;
49128   return jresult;
49129 }
49130
49131
49132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49133   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49134   std::string *arg2 = 0 ;
49135
49136   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49137   if (!jarg2) {
49138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49139     return ;
49140   }
49141   std::string arg2_str(jarg2);
49142   arg2 = &arg2_str;
49143   if (arg1) (arg1)->first = *arg2;
49144
49145   //argout typemap for const std::string&
49146
49147 }
49148
49149
49150 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49151   char * jresult ;
49152   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49153   std::string *result = 0 ;
49154
49155   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49156   result = (std::string *) & ((arg1)->first);
49157   jresult = SWIG_csharp_string_callback(result->c_str());
49158   return jresult;
49159 }
49160
49161
49162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49163   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49164   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49165
49166   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49167   arg2 = (Dali::Property::Value *)jarg2;
49168   if (arg1) (arg1)->second = *arg2;
49169 }
49170
49171
49172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49173   void * jresult ;
49174   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49175   Dali::Property::Value *result = 0 ;
49176
49177   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49178   result = (Dali::Property::Value *)& ((arg1)->second);
49179   jresult = (void *)result;
49180   return jresult;
49181 }
49182
49183
49184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49185   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49186
49187   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49188   {
49189     try {
49190       delete arg1;
49191     } catch (std::out_of_range& e) {
49192       {
49193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49194       };
49195     } catch (std::exception& e) {
49196       {
49197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49198       };
49199     } catch (Dali::DaliException e) {
49200       {
49201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49202       };
49203     } catch (...) {
49204       {
49205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49206       };
49207     }
49208   }
49209
49210 }
49211
49212
49213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49214   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49215
49216   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49217   {
49218     try {
49219       (arg1)->clear();
49220     } catch (std::out_of_range& e) {
49221       {
49222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49223       };
49224     } catch (std::exception& e) {
49225       {
49226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49227       };
49228     } catch (Dali::DaliException e) {
49229       {
49230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49231       };
49232     } catch (...) {
49233       {
49234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49235       };
49236     }
49237   }
49238
49239 }
49240
49241
49242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49243   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49244   Dali::TouchPoint *arg2 = 0 ;
49245
49246   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49247   arg2 = (Dali::TouchPoint *)jarg2;
49248   if (!arg2) {
49249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49250     return ;
49251   }
49252   {
49253     try {
49254       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49255     } catch (std::out_of_range& e) {
49256       {
49257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49258       };
49259     } catch (std::exception& e) {
49260       {
49261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49262       };
49263     } catch (Dali::DaliException e) {
49264       {
49265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49266       };
49267     } catch (...) {
49268       {
49269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49270       };
49271     }
49272   }
49273
49274 }
49275
49276
49277 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49278   unsigned long jresult ;
49279   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49280   std::vector< Dali::TouchPoint >::size_type result;
49281
49282   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49283   {
49284     try {
49285       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49286     } catch (std::out_of_range& e) {
49287       {
49288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49289       };
49290     } catch (std::exception& e) {
49291       {
49292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49293       };
49294     } catch (Dali::DaliException e) {
49295       {
49296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49297       };
49298     } catch (...) {
49299       {
49300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49301       };
49302     }
49303   }
49304
49305   jresult = (unsigned long)result;
49306   return jresult;
49307 }
49308
49309
49310 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49311   unsigned long jresult ;
49312   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49313   std::vector< Dali::TouchPoint >::size_type result;
49314
49315   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49316   {
49317     try {
49318       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49319     } catch (std::out_of_range& e) {
49320       {
49321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49322       };
49323     } catch (std::exception& e) {
49324       {
49325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49326       };
49327     } catch (Dali::DaliException e) {
49328       {
49329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49330       };
49331     } catch (...) {
49332       {
49333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49334       };
49335     }
49336   }
49337
49338   jresult = (unsigned long)result;
49339   return jresult;
49340 }
49341
49342
49343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49344   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49345   std::vector< Dali::TouchPoint >::size_type arg2 ;
49346
49347   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49348   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49349   {
49350     try {
49351       (arg1)->reserve(arg2);
49352     } catch (std::out_of_range& e) {
49353       {
49354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49355       };
49356     } catch (std::exception& e) {
49357       {
49358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49359       };
49360     } catch (Dali::DaliException e) {
49361       {
49362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49363       };
49364     } catch (...) {
49365       {
49366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49367       };
49368     }
49369   }
49370
49371 }
49372
49373
49374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49375   void * jresult ;
49376   std::vector< Dali::TouchPoint > *result = 0 ;
49377
49378   {
49379     try {
49380       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49381     } catch (std::out_of_range& e) {
49382       {
49383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49384       };
49385     } catch (std::exception& e) {
49386       {
49387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49388       };
49389     } catch (Dali::DaliException e) {
49390       {
49391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49392       };
49393     } catch (...) {
49394       {
49395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49396       };
49397     }
49398   }
49399
49400   jresult = (void *)result;
49401   return jresult;
49402 }
49403
49404
49405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49406   void * jresult ;
49407   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49408   std::vector< Dali::TouchPoint > *result = 0 ;
49409
49410   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49411   if (!arg1) {
49412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49413     return 0;
49414   }
49415   {
49416     try {
49417       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49418     } catch (std::out_of_range& e) {
49419       {
49420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49421       };
49422     } catch (std::exception& e) {
49423       {
49424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49425       };
49426     } catch (Dali::DaliException e) {
49427       {
49428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49429       };
49430     } catch (...) {
49431       {
49432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49433       };
49434     }
49435   }
49436
49437   jresult = (void *)result;
49438   return jresult;
49439 }
49440
49441
49442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49443   void * jresult ;
49444   int arg1 ;
49445   std::vector< Dali::TouchPoint > *result = 0 ;
49446
49447   arg1 = (int)jarg1;
49448   {
49449     try {
49450       try {
49451         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49452       }
49453       catch(std::out_of_range &_e) {
49454         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49455         return 0;
49456       }
49457
49458     } catch (std::out_of_range& e) {
49459       {
49460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49461       };
49462     } catch (std::exception& e) {
49463       {
49464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49465       };
49466     } catch (Dali::DaliException e) {
49467       {
49468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49469       };
49470     } catch (...) {
49471       {
49472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49473       };
49474     }
49475   }
49476
49477   jresult = (void *)result;
49478   return jresult;
49479 }
49480
49481
49482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49483   void * jresult ;
49484   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49485   int arg2 ;
49486   SwigValueWrapper< Dali::TouchPoint > result;
49487
49488   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49489   arg2 = (int)jarg2;
49490   {
49491     try {
49492       try {
49493         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49494       }
49495       catch(std::out_of_range &_e) {
49496         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49497         return 0;
49498       }
49499
49500     } catch (std::out_of_range& e) {
49501       {
49502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49503       };
49504     } catch (std::exception& e) {
49505       {
49506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49507       };
49508     } catch (Dali::DaliException e) {
49509       {
49510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49511       };
49512     } catch (...) {
49513       {
49514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49515       };
49516     }
49517   }
49518
49519   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49520   return jresult;
49521 }
49522
49523
49524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49525   void * jresult ;
49526   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49527   int arg2 ;
49528   Dali::TouchPoint *result = 0 ;
49529
49530   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49531   arg2 = (int)jarg2;
49532   {
49533     try {
49534       try {
49535         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49536       }
49537       catch(std::out_of_range &_e) {
49538         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49539         return 0;
49540       }
49541
49542     } catch (std::out_of_range& e) {
49543       {
49544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49545       };
49546     } catch (std::exception& e) {
49547       {
49548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49549       };
49550     } catch (Dali::DaliException e) {
49551       {
49552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49553       };
49554     } catch (...) {
49555       {
49556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49557       };
49558     }
49559   }
49560
49561   jresult = (void *)result;
49562   return jresult;
49563 }
49564
49565
49566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49567   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49568   int arg2 ;
49569   Dali::TouchPoint *arg3 = 0 ;
49570
49571   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49572   arg2 = (int)jarg2;
49573   arg3 = (Dali::TouchPoint *)jarg3;
49574   if (!arg3) {
49575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49576     return ;
49577   }
49578   {
49579     try {
49580       try {
49581         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49582       }
49583       catch(std::out_of_range &_e) {
49584         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49585         return ;
49586       }
49587
49588     } catch (std::out_of_range& e) {
49589       {
49590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49591       };
49592     } catch (std::exception& e) {
49593       {
49594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49595       };
49596     } catch (Dali::DaliException e) {
49597       {
49598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49599       };
49600     } catch (...) {
49601       {
49602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49603       };
49604     }
49605   }
49606
49607 }
49608
49609
49610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49611   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49612   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49613
49614   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49615   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49616   if (!arg2) {
49617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49618     return ;
49619   }
49620   {
49621     try {
49622       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49623     } catch (std::out_of_range& e) {
49624       {
49625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49626       };
49627     } catch (std::exception& e) {
49628       {
49629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49630       };
49631     } catch (Dali::DaliException e) {
49632       {
49633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49634       };
49635     } catch (...) {
49636       {
49637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49638       };
49639     }
49640   }
49641
49642 }
49643
49644
49645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49646   void * jresult ;
49647   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49648   int arg2 ;
49649   int arg3 ;
49650   std::vector< Dali::TouchPoint > *result = 0 ;
49651
49652   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49653   arg2 = (int)jarg2;
49654   arg3 = (int)jarg3;
49655   {
49656     try {
49657       try {
49658         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49659       }
49660       catch(std::out_of_range &_e) {
49661         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49662         return 0;
49663       }
49664       catch(std::invalid_argument &_e) {
49665         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49666         return 0;
49667       }
49668
49669     } catch (std::out_of_range& e) {
49670       {
49671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49672       };
49673     } catch (std::exception& e) {
49674       {
49675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49676       };
49677     } catch (Dali::DaliException e) {
49678       {
49679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49680       };
49681     } catch (...) {
49682       {
49683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49684       };
49685     }
49686   }
49687
49688   jresult = (void *)result;
49689   return jresult;
49690 }
49691
49692
49693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49694   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49695   int arg2 ;
49696   Dali::TouchPoint *arg3 = 0 ;
49697
49698   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49699   arg2 = (int)jarg2;
49700   arg3 = (Dali::TouchPoint *)jarg3;
49701   if (!arg3) {
49702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49703     return ;
49704   }
49705   {
49706     try {
49707       try {
49708         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49709       }
49710       catch(std::out_of_range &_e) {
49711         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49712         return ;
49713       }
49714
49715     } catch (std::out_of_range& e) {
49716       {
49717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49718       };
49719     } catch (std::exception& e) {
49720       {
49721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49722       };
49723     } catch (Dali::DaliException e) {
49724       {
49725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49726       };
49727     } catch (...) {
49728       {
49729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49730       };
49731     }
49732   }
49733
49734 }
49735
49736
49737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49738   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49739   int arg2 ;
49740   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49741
49742   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49743   arg2 = (int)jarg2;
49744   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49745   if (!arg3) {
49746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49747     return ;
49748   }
49749   {
49750     try {
49751       try {
49752         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49753       }
49754       catch(std::out_of_range &_e) {
49755         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49756         return ;
49757       }
49758
49759     } catch (std::out_of_range& e) {
49760       {
49761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49762       };
49763     } catch (std::exception& e) {
49764       {
49765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49766       };
49767     } catch (Dali::DaliException e) {
49768       {
49769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49770       };
49771     } catch (...) {
49772       {
49773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49774       };
49775     }
49776   }
49777
49778 }
49779
49780
49781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49782   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49783   int arg2 ;
49784
49785   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49786   arg2 = (int)jarg2;
49787   {
49788     try {
49789       try {
49790         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49791       }
49792       catch(std::out_of_range &_e) {
49793         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49794         return ;
49795       }
49796
49797     } catch (std::out_of_range& e) {
49798       {
49799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49800       };
49801     } catch (std::exception& e) {
49802       {
49803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49804       };
49805     } catch (Dali::DaliException e) {
49806       {
49807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49808       };
49809     } catch (...) {
49810       {
49811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49812       };
49813     }
49814   }
49815
49816 }
49817
49818
49819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49820   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49821   int arg2 ;
49822   int arg3 ;
49823
49824   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49825   arg2 = (int)jarg2;
49826   arg3 = (int)jarg3;
49827   {
49828     try {
49829       try {
49830         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49831       }
49832       catch(std::out_of_range &_e) {
49833         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49834         return ;
49835       }
49836       catch(std::invalid_argument &_e) {
49837         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49838         return ;
49839       }
49840
49841     } catch (std::out_of_range& e) {
49842       {
49843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49844       };
49845     } catch (std::exception& e) {
49846       {
49847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49848       };
49849     } catch (Dali::DaliException e) {
49850       {
49851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49852       };
49853     } catch (...) {
49854       {
49855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49856       };
49857     }
49858   }
49859
49860 }
49861
49862
49863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49864   void * jresult ;
49865   Dali::TouchPoint *arg1 = 0 ;
49866   int arg2 ;
49867   std::vector< Dali::TouchPoint > *result = 0 ;
49868
49869   arg1 = (Dali::TouchPoint *)jarg1;
49870   if (!arg1) {
49871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49872     return 0;
49873   }
49874   arg2 = (int)jarg2;
49875   {
49876     try {
49877       try {
49878         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49879       }
49880       catch(std::out_of_range &_e) {
49881         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49882         return 0;
49883       }
49884
49885     } catch (std::out_of_range& e) {
49886       {
49887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49888       };
49889     } catch (std::exception& e) {
49890       {
49891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49892       };
49893     } catch (Dali::DaliException e) {
49894       {
49895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49896       };
49897     } catch (...) {
49898       {
49899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49900       };
49901     }
49902   }
49903
49904   jresult = (void *)result;
49905   return jresult;
49906 }
49907
49908
49909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49910   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49911
49912   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49913   {
49914     try {
49915       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49916     } catch (std::out_of_range& e) {
49917       {
49918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49919       };
49920     } catch (std::exception& e) {
49921       {
49922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49923       };
49924     } catch (Dali::DaliException e) {
49925       {
49926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49927       };
49928     } catch (...) {
49929       {
49930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49931       };
49932     }
49933   }
49934
49935 }
49936
49937
49938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49939   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49940   int arg2 ;
49941   int arg3 ;
49942
49943   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49944   arg2 = (int)jarg2;
49945   arg3 = (int)jarg3;
49946   {
49947     try {
49948       try {
49949         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49950       }
49951       catch(std::out_of_range &_e) {
49952         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49953         return ;
49954       }
49955       catch(std::invalid_argument &_e) {
49956         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49957         return ;
49958       }
49959
49960     } catch (std::out_of_range& e) {
49961       {
49962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49963       };
49964     } catch (std::exception& e) {
49965       {
49966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49967       };
49968     } catch (Dali::DaliException e) {
49969       {
49970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49971       };
49972     } catch (...) {
49973       {
49974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49975       };
49976     }
49977   }
49978
49979 }
49980
49981
49982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49983   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49984   int arg2 ;
49985   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49986
49987   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49988   arg2 = (int)jarg2;
49989   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49990   if (!arg3) {
49991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49992     return ;
49993   }
49994   {
49995     try {
49996       try {
49997         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49998       }
49999       catch(std::out_of_range &_e) {
50000         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50001         return ;
50002       }
50003
50004     } catch (std::out_of_range& e) {
50005       {
50006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50007       };
50008     } catch (std::exception& e) {
50009       {
50010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50011       };
50012     } catch (Dali::DaliException e) {
50013       {
50014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50015       };
50016     } catch (...) {
50017       {
50018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50019       };
50020     }
50021   }
50022
50023 }
50024
50025
50026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50027   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50028
50029   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50030   {
50031     try {
50032       delete arg1;
50033     } catch (std::out_of_range& e) {
50034       {
50035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50036       };
50037     } catch (std::exception& e) {
50038       {
50039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50040       };
50041     } catch (Dali::DaliException e) {
50042       {
50043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50044       };
50045     } catch (...) {
50046       {
50047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50048       };
50049     }
50050   }
50051
50052 }
50053
50054
50055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50056   void * jresult ;
50057   Dali::Rect< int > *result = 0 ;
50058
50059   {
50060     try {
50061       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50062     } catch (std::out_of_range& e) {
50063       {
50064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50065       };
50066     } catch (std::exception& e) {
50067       {
50068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50069       };
50070     } catch (Dali::DaliException e) {
50071       {
50072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50073       };
50074     } catch (...) {
50075       {
50076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50077       };
50078     }
50079   }
50080
50081   jresult = (void *)result;
50082   return jresult;
50083 }
50084
50085
50086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50087   void * jresult ;
50088   int arg1 ;
50089   int arg2 ;
50090   int arg3 ;
50091   int arg4 ;
50092   Dali::Rect< int > *result = 0 ;
50093
50094   arg1 = (int)jarg1;
50095   arg2 = (int)jarg2;
50096   arg3 = (int)jarg3;
50097   arg4 = (int)jarg4;
50098   {
50099     try {
50100       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50101     } catch (std::out_of_range& e) {
50102       {
50103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50104       };
50105     } catch (std::exception& e) {
50106       {
50107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50108       };
50109     } catch (Dali::DaliException e) {
50110       {
50111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50112       };
50113     } catch (...) {
50114       {
50115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50116       };
50117     }
50118   }
50119
50120   jresult = (void *)result;
50121   return jresult;
50122 }
50123
50124
50125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50126   void * jresult ;
50127   Dali::Rect< int > *arg1 = 0 ;
50128   Dali::Rect< int > *result = 0 ;
50129
50130   arg1 = (Dali::Rect< int > *)jarg1;
50131   if (!arg1) {
50132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50133     return 0;
50134   }
50135   {
50136     try {
50137       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50138     } catch (std::out_of_range& e) {
50139       {
50140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50141       };
50142     } catch (std::exception& e) {
50143       {
50144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50145       };
50146     } catch (Dali::DaliException e) {
50147       {
50148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50149       };
50150     } catch (...) {
50151       {
50152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50153       };
50154     }
50155   }
50156
50157   jresult = (void *)result;
50158   return jresult;
50159 }
50160
50161
50162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50163   void * jresult ;
50164   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50165   Dali::Rect< int > *arg2 = 0 ;
50166   Dali::Rect< int > *result = 0 ;
50167
50168   arg1 = (Dali::Rect< int > *)jarg1;
50169   arg2 = (Dali::Rect< int > *)jarg2;
50170   if (!arg2) {
50171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50172     return 0;
50173   }
50174   {
50175     try {
50176       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50177     } catch (std::out_of_range& e) {
50178       {
50179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50180       };
50181     } catch (std::exception& e) {
50182       {
50183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50184       };
50185     } catch (Dali::DaliException e) {
50186       {
50187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50188       };
50189     } catch (...) {
50190       {
50191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50192       };
50193     }
50194   }
50195
50196   jresult = (void *)result;
50197   return jresult;
50198 }
50199
50200
50201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50202   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50203   int arg2 ;
50204   int arg3 ;
50205   int arg4 ;
50206   int arg5 ;
50207
50208   arg1 = (Dali::Rect< int > *)jarg1;
50209   arg2 = (int)jarg2;
50210   arg3 = (int)jarg3;
50211   arg4 = (int)jarg4;
50212   arg5 = (int)jarg5;
50213   {
50214     try {
50215       (arg1)->Set(arg2,arg3,arg4,arg5);
50216     } catch (std::out_of_range& e) {
50217       {
50218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50219       };
50220     } catch (std::exception& e) {
50221       {
50222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50223       };
50224     } catch (Dali::DaliException e) {
50225       {
50226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50227       };
50228     } catch (...) {
50229       {
50230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50231       };
50232     }
50233   }
50234
50235 }
50236
50237
50238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50239   unsigned int jresult ;
50240   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50241   bool result;
50242
50243   arg1 = (Dali::Rect< int > *)jarg1;
50244   {
50245     try {
50246       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50247     } catch (std::out_of_range& e) {
50248       {
50249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50250       };
50251     } catch (std::exception& e) {
50252       {
50253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50254       };
50255     } catch (Dali::DaliException e) {
50256       {
50257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50258       };
50259     } catch (...) {
50260       {
50261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50262       };
50263     }
50264   }
50265
50266   jresult = result;
50267   return jresult;
50268 }
50269
50270
50271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50272   int jresult ;
50273   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50274   int result;
50275
50276   arg1 = (Dali::Rect< int > *)jarg1;
50277   {
50278     try {
50279       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50280     } catch (std::out_of_range& e) {
50281       {
50282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50283       };
50284     } catch (std::exception& e) {
50285       {
50286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50287       };
50288     } catch (Dali::DaliException e) {
50289       {
50290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50291       };
50292     } catch (...) {
50293       {
50294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50295       };
50296     }
50297   }
50298
50299   jresult = result;
50300   return jresult;
50301 }
50302
50303
50304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50305   int jresult ;
50306   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50307   int result;
50308
50309   arg1 = (Dali::Rect< int > *)jarg1;
50310   {
50311     try {
50312       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50313     } catch (std::out_of_range& e) {
50314       {
50315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50316       };
50317     } catch (std::exception& e) {
50318       {
50319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50320       };
50321     } catch (Dali::DaliException e) {
50322       {
50323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50324       };
50325     } catch (...) {
50326       {
50327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50328       };
50329     }
50330   }
50331
50332   jresult = result;
50333   return jresult;
50334 }
50335
50336
50337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50338   int jresult ;
50339   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50340   int result;
50341
50342   arg1 = (Dali::Rect< int > *)jarg1;
50343   {
50344     try {
50345       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50346     } catch (std::out_of_range& e) {
50347       {
50348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50349       };
50350     } catch (std::exception& e) {
50351       {
50352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50353       };
50354     } catch (Dali::DaliException e) {
50355       {
50356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50357       };
50358     } catch (...) {
50359       {
50360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50361       };
50362     }
50363   }
50364
50365   jresult = result;
50366   return jresult;
50367 }
50368
50369
50370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50371   int jresult ;
50372   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50373   int result;
50374
50375   arg1 = (Dali::Rect< int > *)jarg1;
50376   {
50377     try {
50378       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50379     } catch (std::out_of_range& e) {
50380       {
50381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50382       };
50383     } catch (std::exception& e) {
50384       {
50385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50386       };
50387     } catch (Dali::DaliException e) {
50388       {
50389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50390       };
50391     } catch (...) {
50392       {
50393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50394       };
50395     }
50396   }
50397
50398   jresult = result;
50399   return jresult;
50400 }
50401
50402
50403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50404   int jresult ;
50405   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50406   int result;
50407
50408   arg1 = (Dali::Rect< int > *)jarg1;
50409   {
50410     try {
50411       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50412     } catch (std::out_of_range& e) {
50413       {
50414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50415       };
50416     } catch (std::exception& e) {
50417       {
50418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50419       };
50420     } catch (Dali::DaliException e) {
50421       {
50422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50423       };
50424     } catch (...) {
50425       {
50426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50427       };
50428     }
50429   }
50430
50431   jresult = result;
50432   return jresult;
50433 }
50434
50435
50436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50437   unsigned int jresult ;
50438   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50439   Dali::Rect< int > *arg2 = 0 ;
50440   bool result;
50441
50442   arg1 = (Dali::Rect< int > *)jarg1;
50443   arg2 = (Dali::Rect< int > *)jarg2;
50444   if (!arg2) {
50445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50446     return 0;
50447   }
50448   {
50449     try {
50450       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50451     } catch (std::out_of_range& e) {
50452       {
50453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50454       };
50455     } catch (std::exception& e) {
50456       {
50457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50458       };
50459     } catch (Dali::DaliException e) {
50460       {
50461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50462       };
50463     } catch (...) {
50464       {
50465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50466       };
50467     }
50468   }
50469
50470   jresult = result;
50471   return jresult;
50472 }
50473
50474
50475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50476   unsigned int jresult ;
50477   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50478   Dali::Rect< int > *arg2 = 0 ;
50479   bool result;
50480
50481   arg1 = (Dali::Rect< int > *)jarg1;
50482   arg2 = (Dali::Rect< int > *)jarg2;
50483   if (!arg2) {
50484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50485     return 0;
50486   }
50487   {
50488     try {
50489       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50490     } catch (std::out_of_range& e) {
50491       {
50492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50493       };
50494     } catch (std::exception& e) {
50495       {
50496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50497       };
50498     } catch (Dali::DaliException e) {
50499       {
50500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50501       };
50502     } catch (...) {
50503       {
50504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50505       };
50506     }
50507   }
50508
50509   jresult = result;
50510   return jresult;
50511 }
50512
50513
50514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50515   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50516   int arg2 ;
50517
50518   arg1 = (Dali::Rect< int > *)jarg1;
50519   arg2 = (int)jarg2;
50520   if (arg1) (arg1)->x = arg2;
50521 }
50522
50523
50524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50525   int jresult ;
50526   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50527   int result;
50528
50529   arg1 = (Dali::Rect< int > *)jarg1;
50530   result = (int) ((arg1)->x);
50531   jresult = result;
50532   return jresult;
50533 }
50534
50535
50536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50537   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50538   int arg2 ;
50539
50540   arg1 = (Dali::Rect< int > *)jarg1;
50541   arg2 = (int)jarg2;
50542   if (arg1) (arg1)->left = arg2;
50543 }
50544
50545
50546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50547   int jresult ;
50548   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50549   int result;
50550
50551   arg1 = (Dali::Rect< int > *)jarg1;
50552   result = (int) ((arg1)->left);
50553   jresult = result;
50554   return jresult;
50555 }
50556
50557
50558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50559   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50560   int arg2 ;
50561
50562   arg1 = (Dali::Rect< int > *)jarg1;
50563   arg2 = (int)jarg2;
50564   if (arg1) (arg1)->y = arg2;
50565 }
50566
50567
50568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50569   int jresult ;
50570   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50571   int result;
50572
50573   arg1 = (Dali::Rect< int > *)jarg1;
50574   result = (int) ((arg1)->y);
50575   jresult = result;
50576   return jresult;
50577 }
50578
50579
50580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50581   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50582   int arg2 ;
50583
50584   arg1 = (Dali::Rect< int > *)jarg1;
50585   arg2 = (int)jarg2;
50586   if (arg1) (arg1)->right = arg2;
50587 }
50588
50589
50590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50591   int jresult ;
50592   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50593   int result;
50594
50595   arg1 = (Dali::Rect< int > *)jarg1;
50596   result = (int) ((arg1)->right);
50597   jresult = result;
50598   return jresult;
50599 }
50600
50601
50602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50603   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50604   int arg2 ;
50605
50606   arg1 = (Dali::Rect< int > *)jarg1;
50607   arg2 = (int)jarg2;
50608   if (arg1) (arg1)->width = arg2;
50609 }
50610
50611
50612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50613   int jresult ;
50614   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50615   int result;
50616
50617   arg1 = (Dali::Rect< int > *)jarg1;
50618   result = (int) ((arg1)->width);
50619   jresult = result;
50620   return jresult;
50621 }
50622
50623
50624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50625   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50626   int arg2 ;
50627
50628   arg1 = (Dali::Rect< int > *)jarg1;
50629   arg2 = (int)jarg2;
50630   if (arg1) (arg1)->bottom = arg2;
50631 }
50632
50633
50634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50635   int jresult ;
50636   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50637   int result;
50638
50639   arg1 = (Dali::Rect< int > *)jarg1;
50640   result = (int) ((arg1)->bottom);
50641   jresult = result;
50642   return jresult;
50643 }
50644
50645
50646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50647   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50648   int arg2 ;
50649
50650   arg1 = (Dali::Rect< int > *)jarg1;
50651   arg2 = (int)jarg2;
50652   if (arg1) (arg1)->height = arg2;
50653 }
50654
50655
50656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50657   int jresult ;
50658   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50659   int result;
50660
50661   arg1 = (Dali::Rect< int > *)jarg1;
50662   result = (int) ((arg1)->height);
50663   jresult = result;
50664   return jresult;
50665 }
50666
50667
50668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50669   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50670   int arg2 ;
50671
50672   arg1 = (Dali::Rect< int > *)jarg1;
50673   arg2 = (int)jarg2;
50674   if (arg1) (arg1)->top = arg2;
50675 }
50676
50677
50678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50679   int jresult ;
50680   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50681   int result;
50682
50683   arg1 = (Dali::Rect< int > *)jarg1;
50684   result = (int) ((arg1)->top);
50685   jresult = result;
50686   return jresult;
50687 }
50688
50689
50690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50691   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50692
50693   arg1 = (Dali::Rect< int > *)jarg1;
50694   {
50695     try {
50696       delete arg1;
50697     } catch (std::out_of_range& e) {
50698       {
50699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50700       };
50701     } catch (std::exception& e) {
50702       {
50703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50704       };
50705     } catch (Dali::DaliException e) {
50706       {
50707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50708       };
50709     } catch (...) {
50710       {
50711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50712       };
50713     }
50714   }
50715
50716 }
50717
50718
50719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50720   void * jresult ;
50721   Dali::Rect< float > *result = 0 ;
50722
50723   {
50724     try {
50725       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50726     } catch (std::out_of_range& e) {
50727       {
50728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50729       };
50730     } catch (std::exception& e) {
50731       {
50732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50733       };
50734     } catch (Dali::DaliException e) {
50735       {
50736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50737       };
50738     } catch (...) {
50739       {
50740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50741       };
50742     }
50743   }
50744
50745   jresult = (void *)result;
50746   return jresult;
50747 }
50748
50749
50750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50751   void * jresult ;
50752   float arg1 ;
50753   float arg2 ;
50754   float arg3 ;
50755   float arg4 ;
50756   Dali::Rect< float > *result = 0 ;
50757
50758   arg1 = (float)jarg1;
50759   arg2 = (float)jarg2;
50760   arg3 = (float)jarg4;
50761   arg4 = (float)jarg3;
50762   {
50763     try {
50764       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50765     } catch (std::out_of_range& e) {
50766       {
50767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50768       };
50769     } catch (std::exception& e) {
50770       {
50771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50772       };
50773     } catch (Dali::DaliException e) {
50774       {
50775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50776       };
50777     } catch (...) {
50778       {
50779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50780       };
50781     }
50782   }
50783
50784   jresult = (void *)result;
50785   return jresult;
50786 }
50787
50788
50789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50790   void * jresult ;
50791   Dali::Rect< float > *arg1 = 0 ;
50792   Dali::Rect< float > *result = 0 ;
50793
50794   arg1 = (Dali::Rect< float > *)jarg1;
50795   if (!arg1) {
50796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50797     return 0;
50798   }
50799   {
50800     try {
50801       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50802     } catch (std::out_of_range& e) {
50803       {
50804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50805       };
50806     } catch (std::exception& e) {
50807       {
50808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50809       };
50810     } catch (Dali::DaliException e) {
50811       {
50812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50813       };
50814     } catch (...) {
50815       {
50816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50817       };
50818     }
50819   }
50820
50821   jresult = (void *)result;
50822   return jresult;
50823 }
50824
50825
50826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50827   void * jresult ;
50828   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50829   Dali::Rect< float > *arg2 = 0 ;
50830   Dali::Rect< float > *result = 0 ;
50831
50832   arg1 = (Dali::Rect< float > *)jarg1;
50833   arg2 = (Dali::Rect< float > *)jarg2;
50834   if (!arg2) {
50835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50836     return 0;
50837   }
50838   {
50839     try {
50840       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50841     } catch (std::out_of_range& e) {
50842       {
50843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50844       };
50845     } catch (std::exception& e) {
50846       {
50847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50848       };
50849     } catch (Dali::DaliException e) {
50850       {
50851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50852       };
50853     } catch (...) {
50854       {
50855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50856       };
50857     }
50858   }
50859
50860   jresult = (void *)result;
50861   return jresult;
50862 }
50863
50864
50865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50866   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50867   float arg2 ;
50868   float arg3 ;
50869   float arg4 ;
50870   float arg5 ;
50871
50872   arg1 = (Dali::Rect< float > *)jarg1;
50873   arg2 = (float)jarg2;
50874   arg3 = (float)jarg3;
50875   arg4 = (float)jarg5;
50876   arg5 = (float)jarg4;
50877   {
50878     try {
50879       (arg1)->Set(arg2,arg3,arg4,arg5);
50880     } catch (std::out_of_range& e) {
50881       {
50882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50883       };
50884     } catch (std::exception& e) {
50885       {
50886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50887       };
50888     } catch (Dali::DaliException e) {
50889       {
50890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50891       };
50892     } catch (...) {
50893       {
50894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50895       };
50896     }
50897   }
50898
50899 }
50900
50901
50902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50903   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50904   float arg2 ;
50905
50906   arg1 = (Dali::Rect< float > *)jarg1;
50907   arg2 = (float)jarg2;
50908   if (arg1) (arg1)->left = arg2;
50909 }
50910
50911
50912 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50913   float jresult ;
50914   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50915   float result;
50916
50917   arg1 = (Dali::Rect< float > *)jarg1;
50918   result = (float) ((arg1)->left);
50919   jresult = result;
50920   return jresult;
50921 }
50922
50923
50924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50925   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50926   float arg2 ;
50927
50928   arg1 = (Dali::Rect< float > *)jarg1;
50929   arg2 = (float)jarg2;
50930   if (arg1) (arg1)->left = arg2;
50931 }
50932
50933
50934 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50935   float jresult ;
50936   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50937   float result;
50938
50939   arg1 = (Dali::Rect< float > *)jarg1;
50940   result = (float) ((arg1)->left);
50941   jresult = result;
50942   return jresult;
50943 }
50944
50945
50946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50947   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50948   float arg2 ;
50949
50950   arg1 = (Dali::Rect< float > *)jarg1;
50951   arg2 = (float)jarg2;
50952   if (arg1) (arg1)->right = arg2;
50953 }
50954
50955
50956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50957   float jresult ;
50958   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50959   float result;
50960
50961   arg1 = (Dali::Rect< float > *)jarg1;
50962   result = (float) ((arg1)->right);
50963   jresult = result;
50964   return jresult;
50965 }
50966
50967
50968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50969   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50970   float arg2 ;
50971
50972   arg1 = (Dali::Rect< float > *)jarg1;
50973   arg2 = (float)jarg2;
50974   if (arg1) (arg1)->right = arg2;
50975 }
50976
50977
50978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50979   float jresult ;
50980   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50981   float result;
50982
50983   arg1 = (Dali::Rect< float > *)jarg1;
50984   result = (float) ((arg1)->right);
50985   jresult = result;
50986   return jresult;
50987 }
50988
50989
50990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50991   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50992   float arg2 ;
50993
50994   arg1 = (Dali::Rect< float > *)jarg1;
50995   arg2 = (float)jarg2;
50996   if (arg1) (arg1)->bottom = arg2;
50997 }
50998
50999
51000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51001   float jresult ;
51002   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51003   float result;
51004
51005   arg1 = (Dali::Rect< float > *)jarg1;
51006   result = (float) ((arg1)->bottom);
51007   jresult = result;
51008   return jresult;
51009 }
51010
51011
51012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51013   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51014   float arg2 ;
51015
51016   arg1 = (Dali::Rect< float > *)jarg1;
51017   arg2 = (float)jarg2;
51018   if (arg1) (arg1)->top = arg2;
51019 }
51020
51021
51022 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51023   float jresult ;
51024   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51025   float result;
51026
51027   arg1 = (Dali::Rect< float > *)jarg1;
51028   result = (float) ((arg1)->top);
51029   jresult = result;
51030   return jresult;
51031 }
51032
51033
51034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51035   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51036
51037   arg1 = (Dali::Rect< float > *)jarg1;
51038   {
51039     try {
51040       delete arg1;
51041     } catch (std::out_of_range& e) {
51042       {
51043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51044       };
51045     } catch (std::exception& e) {
51046       {
51047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51048       };
51049     } catch (Dali::DaliException e) {
51050       {
51051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51052       };
51053     } catch (...) {
51054       {
51055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51056       };
51057     }
51058   }
51059
51060 }
51061
51062
51063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51064   int jresult ;
51065   int result;
51066
51067   result = (int)Dali::Vector< int >::BaseType;
51068   jresult = (int)result;
51069   return jresult;
51070 }
51071
51072
51073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51074   void * jresult ;
51075   Dali::Vector< int > *result = 0 ;
51076
51077   {
51078     try {
51079       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51080     } catch (std::out_of_range& e) {
51081       {
51082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51083       };
51084     } catch (std::exception& e) {
51085       {
51086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51087       };
51088     } catch (Dali::DaliException e) {
51089       {
51090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51091       };
51092     } catch (...) {
51093       {
51094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51095       };
51096     }
51097   }
51098
51099   jresult = (void *)result;
51100   return jresult;
51101 }
51102
51103
51104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51105   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51106
51107   arg1 = (Dali::Vector< int > *)jarg1;
51108   {
51109     try {
51110       delete arg1;
51111     } catch (std::out_of_range& e) {
51112       {
51113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51114       };
51115     } catch (std::exception& e) {
51116       {
51117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51118       };
51119     } catch (Dali::DaliException e) {
51120       {
51121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51122       };
51123     } catch (...) {
51124       {
51125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51126       };
51127     }
51128   }
51129
51130 }
51131
51132
51133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51134   void * jresult ;
51135   Dali::Vector< int > *arg1 = 0 ;
51136   Dali::Vector< int > *result = 0 ;
51137
51138   arg1 = (Dali::Vector< int > *)jarg1;
51139   if (!arg1) {
51140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51141     return 0;
51142   }
51143   {
51144     try {
51145       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51146     } catch (std::out_of_range& e) {
51147       {
51148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51149       };
51150     } catch (std::exception& e) {
51151       {
51152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51153       };
51154     } catch (Dali::DaliException e) {
51155       {
51156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51157       };
51158     } catch (...) {
51159       {
51160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51161       };
51162     }
51163   }
51164
51165   jresult = (void *)result;
51166   return jresult;
51167 }
51168
51169
51170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51171   void * jresult ;
51172   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51173   Dali::Vector< int > *arg2 = 0 ;
51174   Dali::Vector< int > *result = 0 ;
51175
51176   arg1 = (Dali::Vector< int > *)jarg1;
51177   arg2 = (Dali::Vector< int > *)jarg2;
51178   if (!arg2) {
51179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51180     return 0;
51181   }
51182   {
51183     try {
51184       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51185     } catch (std::out_of_range& e) {
51186       {
51187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51188       };
51189     } catch (std::exception& e) {
51190       {
51191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51192       };
51193     } catch (Dali::DaliException e) {
51194       {
51195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51196       };
51197     } catch (...) {
51198       {
51199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51200       };
51201     }
51202   }
51203
51204   jresult = (void *)result;
51205   return jresult;
51206 }
51207
51208
51209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51210   void * jresult ;
51211   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51212   Dali::Vector< int >::Iterator result;
51213
51214   arg1 = (Dali::Vector< int > *)jarg1;
51215   {
51216     try {
51217       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51218     } catch (std::out_of_range& e) {
51219       {
51220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51221       };
51222     } catch (std::exception& e) {
51223       {
51224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51225       };
51226     } catch (Dali::DaliException e) {
51227       {
51228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51229       };
51230     } catch (...) {
51231       {
51232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51233       };
51234     }
51235   }
51236
51237   jresult = (void *)result;
51238   return jresult;
51239 }
51240
51241
51242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51243   void * jresult ;
51244   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51245   Dali::Vector< int >::Iterator result;
51246
51247   arg1 = (Dali::Vector< int > *)jarg1;
51248   {
51249     try {
51250       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51251     } catch (std::out_of_range& e) {
51252       {
51253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51254       };
51255     } catch (std::exception& e) {
51256       {
51257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51258       };
51259     } catch (Dali::DaliException e) {
51260       {
51261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51262       };
51263     } catch (...) {
51264       {
51265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51266       };
51267     }
51268   }
51269
51270   jresult = (void *)result;
51271   return jresult;
51272 }
51273
51274
51275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51276   void * jresult ;
51277   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51278   Dali::Vector< int >::SizeType arg2 ;
51279   Dali::Vector< int >::ItemType *result = 0 ;
51280
51281   arg1 = (Dali::Vector< int > *)jarg1;
51282   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51283   {
51284     try {
51285       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51286     } catch (std::out_of_range& e) {
51287       {
51288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51289       };
51290     } catch (std::exception& e) {
51291       {
51292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51293       };
51294     } catch (Dali::DaliException e) {
51295       {
51296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51297       };
51298     } catch (...) {
51299       {
51300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51301       };
51302     }
51303   }
51304
51305   jresult = (void *)result;
51306   return jresult;
51307 }
51308
51309
51310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51311   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51312   Dali::Vector< int >::ItemType *arg2 = 0 ;
51313   Dali::Vector< int >::ItemType temp2 ;
51314
51315   arg1 = (Dali::Vector< int > *)jarg1;
51316   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51317   arg2 = &temp2;
51318   {
51319     try {
51320       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51321     } catch (std::out_of_range& e) {
51322       {
51323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51324       };
51325     } catch (std::exception& e) {
51326       {
51327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51328       };
51329     } catch (Dali::DaliException e) {
51330       {
51331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51332       };
51333     } catch (...) {
51334       {
51335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51336       };
51337     }
51338   }
51339
51340 }
51341
51342
51343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51344   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51345   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51346   Dali::Vector< int >::ItemType *arg3 = 0 ;
51347   Dali::Vector< int >::ItemType temp3 ;
51348
51349   arg1 = (Dali::Vector< int > *)jarg1;
51350   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51351   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51352   arg3 = &temp3;
51353   {
51354     try {
51355       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51356     } catch (std::out_of_range& e) {
51357       {
51358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51359       };
51360     } catch (std::exception& e) {
51361       {
51362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51363       };
51364     } catch (Dali::DaliException e) {
51365       {
51366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51367       };
51368     } catch (...) {
51369       {
51370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51371       };
51372     }
51373   }
51374
51375 }
51376
51377
51378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51379   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51380   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51381   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51382   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51383
51384   arg1 = (Dali::Vector< int > *)jarg1;
51385   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51386   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51387   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51388   {
51389     try {
51390       (arg1)->Insert(arg2,arg3,arg4);
51391     } catch (std::out_of_range& e) {
51392       {
51393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51394       };
51395     } catch (std::exception& e) {
51396       {
51397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51398       };
51399     } catch (Dali::DaliException e) {
51400       {
51401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51402       };
51403     } catch (...) {
51404       {
51405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51406       };
51407     }
51408   }
51409
51410 }
51411
51412
51413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51414   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51415   Dali::Vector< int >::SizeType arg2 ;
51416
51417   arg1 = (Dali::Vector< int > *)jarg1;
51418   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51419   {
51420     try {
51421       (arg1)->Reserve(arg2);
51422     } catch (std::out_of_range& e) {
51423       {
51424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51425       };
51426     } catch (std::exception& e) {
51427       {
51428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51429       };
51430     } catch (Dali::DaliException e) {
51431       {
51432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51433       };
51434     } catch (...) {
51435       {
51436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51437       };
51438     }
51439   }
51440
51441 }
51442
51443
51444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51445   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51446   Dali::Vector< int >::SizeType arg2 ;
51447
51448   arg1 = (Dali::Vector< int > *)jarg1;
51449   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51450   {
51451     try {
51452       (arg1)->Resize(arg2);
51453     } catch (std::out_of_range& e) {
51454       {
51455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51456       };
51457     } catch (std::exception& e) {
51458       {
51459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51460       };
51461     } catch (Dali::DaliException e) {
51462       {
51463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51464       };
51465     } catch (...) {
51466       {
51467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51468       };
51469     }
51470   }
51471
51472 }
51473
51474
51475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51476   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51477   Dali::Vector< int >::SizeType arg2 ;
51478   Dali::Vector< int >::ItemType *arg3 = 0 ;
51479   Dali::Vector< int >::ItemType temp3 ;
51480
51481   arg1 = (Dali::Vector< int > *)jarg1;
51482   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51483   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51484   arg3 = &temp3;
51485   {
51486     try {
51487       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51488     } catch (std::out_of_range& e) {
51489       {
51490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51491       };
51492     } catch (std::exception& e) {
51493       {
51494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51495       };
51496     } catch (Dali::DaliException e) {
51497       {
51498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51499       };
51500     } catch (...) {
51501       {
51502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51503       };
51504     }
51505   }
51506
51507 }
51508
51509
51510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51511   void * jresult ;
51512   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51513   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51514   Dali::Vector< int >::Iterator result;
51515
51516   arg1 = (Dali::Vector< int > *)jarg1;
51517   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51518   {
51519     try {
51520       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51521     } catch (std::out_of_range& e) {
51522       {
51523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51524       };
51525     } catch (std::exception& e) {
51526       {
51527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51528       };
51529     } catch (Dali::DaliException e) {
51530       {
51531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51532       };
51533     } catch (...) {
51534       {
51535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51536       };
51537     }
51538   }
51539
51540   jresult = (void *)result;
51541   return jresult;
51542 }
51543
51544
51545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51546   void * jresult ;
51547   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51548   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51549   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51550   Dali::Vector< int >::Iterator result;
51551
51552   arg1 = (Dali::Vector< int > *)jarg1;
51553   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51554   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51555   {
51556     try {
51557       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51558     } catch (std::out_of_range& e) {
51559       {
51560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51561       };
51562     } catch (std::exception& e) {
51563       {
51564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51565       };
51566     } catch (Dali::DaliException e) {
51567       {
51568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51569       };
51570     } catch (...) {
51571       {
51572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51573       };
51574     }
51575   }
51576
51577   jresult = (void *)result;
51578   return jresult;
51579 }
51580
51581
51582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51583   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51584   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51585
51586   arg1 = (Dali::Vector< int > *)jarg1;
51587   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51588   {
51589     try {
51590       (arg1)->Remove(arg2);
51591     } catch (std::out_of_range& e) {
51592       {
51593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51594       };
51595     } catch (std::exception& e) {
51596       {
51597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51598       };
51599     } catch (Dali::DaliException e) {
51600       {
51601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51602       };
51603     } catch (...) {
51604       {
51605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51606       };
51607     }
51608   }
51609
51610 }
51611
51612
51613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51614   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51615   Dali::Vector< int > *arg2 = 0 ;
51616
51617   arg1 = (Dali::Vector< int > *)jarg1;
51618   arg2 = (Dali::Vector< int > *)jarg2;
51619   if (!arg2) {
51620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51621     return ;
51622   }
51623   {
51624     try {
51625       (arg1)->Swap(*arg2);
51626     } catch (std::out_of_range& e) {
51627       {
51628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51629       };
51630     } catch (std::exception& e) {
51631       {
51632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51633       };
51634     } catch (Dali::DaliException e) {
51635       {
51636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51637       };
51638     } catch (...) {
51639       {
51640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51641       };
51642     }
51643   }
51644
51645 }
51646
51647
51648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51649   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51650
51651   arg1 = (Dali::Vector< int > *)jarg1;
51652   {
51653     try {
51654       (arg1)->Clear();
51655     } catch (std::out_of_range& e) {
51656       {
51657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51658       };
51659     } catch (std::exception& e) {
51660       {
51661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51662       };
51663     } catch (Dali::DaliException e) {
51664       {
51665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51666       };
51667     } catch (...) {
51668       {
51669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51670       };
51671     }
51672   }
51673
51674 }
51675
51676
51677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51678   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51679
51680   arg1 = (Dali::Vector< int > *)jarg1;
51681   {
51682     try {
51683       (arg1)->Release();
51684     } catch (std::out_of_range& e) {
51685       {
51686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51687       };
51688     } catch (std::exception& e) {
51689       {
51690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51691       };
51692     } catch (Dali::DaliException e) {
51693       {
51694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51695       };
51696     } catch (...) {
51697       {
51698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51699       };
51700     }
51701   }
51702
51703 }
51704
51705
51706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51707   int jresult ;
51708   int result;
51709
51710   result = (int)Dali::Vector< float >::BaseType;
51711   jresult = (int)result;
51712   return jresult;
51713 }
51714
51715
51716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51717   void * jresult ;
51718   Dali::Vector< float > *result = 0 ;
51719
51720   {
51721     try {
51722       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51723     } catch (std::out_of_range& e) {
51724       {
51725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51726       };
51727     } catch (std::exception& e) {
51728       {
51729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51730       };
51731     } catch (Dali::DaliException e) {
51732       {
51733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51734       };
51735     } catch (...) {
51736       {
51737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51738       };
51739     }
51740   }
51741
51742   jresult = (void *)result;
51743   return jresult;
51744 }
51745
51746
51747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51748   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51749
51750   arg1 = (Dali::Vector< float > *)jarg1;
51751   {
51752     try {
51753       delete arg1;
51754     } catch (std::out_of_range& e) {
51755       {
51756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51757       };
51758     } catch (std::exception& e) {
51759       {
51760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51761       };
51762     } catch (Dali::DaliException e) {
51763       {
51764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51765       };
51766     } catch (...) {
51767       {
51768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51769       };
51770     }
51771   }
51772
51773 }
51774
51775
51776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51777   void * jresult ;
51778   Dali::Vector< float > *arg1 = 0 ;
51779   Dali::Vector< float > *result = 0 ;
51780
51781   arg1 = (Dali::Vector< float > *)jarg1;
51782   if (!arg1) {
51783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51784     return 0;
51785   }
51786   {
51787     try {
51788       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51789     } catch (std::out_of_range& e) {
51790       {
51791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51792       };
51793     } catch (std::exception& e) {
51794       {
51795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51796       };
51797     } catch (Dali::DaliException e) {
51798       {
51799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51800       };
51801     } catch (...) {
51802       {
51803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51804       };
51805     }
51806   }
51807
51808   jresult = (void *)result;
51809   return jresult;
51810 }
51811
51812
51813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51814   void * jresult ;
51815   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51816   Dali::Vector< float > *arg2 = 0 ;
51817   Dali::Vector< float > *result = 0 ;
51818
51819   arg1 = (Dali::Vector< float > *)jarg1;
51820   arg2 = (Dali::Vector< float > *)jarg2;
51821   if (!arg2) {
51822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51823     return 0;
51824   }
51825   {
51826     try {
51827       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51828     } catch (std::out_of_range& e) {
51829       {
51830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51831       };
51832     } catch (std::exception& e) {
51833       {
51834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51835       };
51836     } catch (Dali::DaliException e) {
51837       {
51838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51839       };
51840     } catch (...) {
51841       {
51842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51843       };
51844     }
51845   }
51846
51847   jresult = (void *)result;
51848   return jresult;
51849 }
51850
51851
51852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51853   void * jresult ;
51854   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51855   Dali::Vector< float >::Iterator result;
51856
51857   arg1 = (Dali::Vector< float > *)jarg1;
51858   {
51859     try {
51860       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51861     } catch (std::out_of_range& e) {
51862       {
51863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51864       };
51865     } catch (std::exception& e) {
51866       {
51867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51868       };
51869     } catch (Dali::DaliException e) {
51870       {
51871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51872       };
51873     } catch (...) {
51874       {
51875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51876       };
51877     }
51878   }
51879
51880   jresult = (void *)result;
51881   return jresult;
51882 }
51883
51884
51885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51886   void * jresult ;
51887   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51888   Dali::Vector< float >::Iterator result;
51889
51890   arg1 = (Dali::Vector< float > *)jarg1;
51891   {
51892     try {
51893       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51894     } catch (std::out_of_range& e) {
51895       {
51896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51897       };
51898     } catch (std::exception& e) {
51899       {
51900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51901       };
51902     } catch (Dali::DaliException e) {
51903       {
51904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51905       };
51906     } catch (...) {
51907       {
51908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51909       };
51910     }
51911   }
51912
51913   jresult = (void *)result;
51914   return jresult;
51915 }
51916
51917
51918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51919   void * jresult ;
51920   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51921   Dali::Vector< float >::SizeType arg2 ;
51922   Dali::Vector< float >::ItemType *result = 0 ;
51923
51924   arg1 = (Dali::Vector< float > *)jarg1;
51925   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51926   {
51927     try {
51928       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51929     } catch (std::out_of_range& e) {
51930       {
51931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51932       };
51933     } catch (std::exception& e) {
51934       {
51935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51936       };
51937     } catch (Dali::DaliException e) {
51938       {
51939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51940       };
51941     } catch (...) {
51942       {
51943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51944       };
51945     }
51946   }
51947
51948   jresult = (void *)result;
51949   return jresult;
51950 }
51951
51952
51953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51954   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51955   Dali::Vector< float >::ItemType *arg2 = 0 ;
51956   Dali::Vector< float >::ItemType temp2 ;
51957
51958   arg1 = (Dali::Vector< float > *)jarg1;
51959   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51960   arg2 = &temp2;
51961   {
51962     try {
51963       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51964     } catch (std::out_of_range& e) {
51965       {
51966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51967       };
51968     } catch (std::exception& e) {
51969       {
51970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51971       };
51972     } catch (Dali::DaliException e) {
51973       {
51974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51975       };
51976     } catch (...) {
51977       {
51978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51979       };
51980     }
51981   }
51982
51983 }
51984
51985
51986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51987   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51988   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51989   Dali::Vector< float >::ItemType *arg3 = 0 ;
51990   Dali::Vector< float >::ItemType temp3 ;
51991
51992   arg1 = (Dali::Vector< float > *)jarg1;
51993   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51994   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51995   arg3 = &temp3;
51996   {
51997     try {
51998       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51999     } catch (std::out_of_range& e) {
52000       {
52001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52002       };
52003     } catch (std::exception& e) {
52004       {
52005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52006       };
52007     } catch (Dali::DaliException e) {
52008       {
52009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52010       };
52011     } catch (...) {
52012       {
52013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52014       };
52015     }
52016   }
52017
52018 }
52019
52020
52021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52022   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52023   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52024   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52025   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52026
52027   arg1 = (Dali::Vector< float > *)jarg1;
52028   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52029   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52030   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52031   {
52032     try {
52033       (arg1)->Insert(arg2,arg3,arg4);
52034     } catch (std::out_of_range& e) {
52035       {
52036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52037       };
52038     } catch (std::exception& e) {
52039       {
52040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52041       };
52042     } catch (Dali::DaliException e) {
52043       {
52044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52045       };
52046     } catch (...) {
52047       {
52048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52049       };
52050     }
52051   }
52052
52053 }
52054
52055
52056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52057   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52058   Dali::Vector< float >::SizeType arg2 ;
52059
52060   arg1 = (Dali::Vector< float > *)jarg1;
52061   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52062   {
52063     try {
52064       (arg1)->Reserve(arg2);
52065     } catch (std::out_of_range& e) {
52066       {
52067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52068       };
52069     } catch (std::exception& e) {
52070       {
52071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52072       };
52073     } catch (Dali::DaliException e) {
52074       {
52075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52076       };
52077     } catch (...) {
52078       {
52079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52080       };
52081     }
52082   }
52083
52084 }
52085
52086 //// ========================= end of part 2 =============================
52087
52088 //// ========================== start part 3 ===============================
52089
52090
52091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52092   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52093   Dali::Vector< float >::SizeType arg2 ;
52094
52095   arg1 = (Dali::Vector< float > *)jarg1;
52096   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52097   {
52098     try {
52099       (arg1)->Resize(arg2);
52100     } catch (std::out_of_range& e) {
52101       {
52102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52103       };
52104     } catch (std::exception& e) {
52105       {
52106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52107       };
52108     } catch (Dali::DaliException e) {
52109       {
52110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52111       };
52112     } catch (...) {
52113       {
52114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52115       };
52116     }
52117   }
52118
52119 }
52120
52121
52122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52123   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52124   Dali::Vector< float >::SizeType arg2 ;
52125   Dali::Vector< float >::ItemType *arg3 = 0 ;
52126   Dali::Vector< float >::ItemType temp3 ;
52127
52128   arg1 = (Dali::Vector< float > *)jarg1;
52129   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52130   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52131   arg3 = &temp3;
52132   {
52133     try {
52134       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52135     } catch (std::out_of_range& e) {
52136       {
52137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52138       };
52139     } catch (std::exception& e) {
52140       {
52141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52142       };
52143     } catch (Dali::DaliException e) {
52144       {
52145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52146       };
52147     } catch (...) {
52148       {
52149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52150       };
52151     }
52152   }
52153
52154 }
52155
52156
52157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52158   void * jresult ;
52159   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52160   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52161   Dali::Vector< float >::Iterator result;
52162
52163   arg1 = (Dali::Vector< float > *)jarg1;
52164   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52165   {
52166     try {
52167       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52168     } catch (std::out_of_range& e) {
52169       {
52170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52171       };
52172     } catch (std::exception& e) {
52173       {
52174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52175       };
52176     } catch (Dali::DaliException e) {
52177       {
52178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52179       };
52180     } catch (...) {
52181       {
52182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52183       };
52184     }
52185   }
52186
52187   jresult = (void *)result;
52188   return jresult;
52189 }
52190
52191
52192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52193   void * jresult ;
52194   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52195   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52196   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52197   Dali::Vector< float >::Iterator result;
52198
52199   arg1 = (Dali::Vector< float > *)jarg1;
52200   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52201   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52202   {
52203     try {
52204       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52205     } catch (std::out_of_range& e) {
52206       {
52207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52208       };
52209     } catch (std::exception& e) {
52210       {
52211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52212       };
52213     } catch (Dali::DaliException e) {
52214       {
52215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52216       };
52217     } catch (...) {
52218       {
52219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52220       };
52221     }
52222   }
52223
52224   jresult = (void *)result;
52225   return jresult;
52226 }
52227
52228
52229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52230   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52231   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52232
52233   arg1 = (Dali::Vector< float > *)jarg1;
52234   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52235   {
52236     try {
52237       (arg1)->Remove(arg2);
52238     } catch (std::out_of_range& e) {
52239       {
52240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52241       };
52242     } catch (std::exception& e) {
52243       {
52244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52245       };
52246     } catch (Dali::DaliException e) {
52247       {
52248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52249       };
52250     } catch (...) {
52251       {
52252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52253       };
52254     }
52255   }
52256
52257 }
52258
52259
52260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52261   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52262   Dali::Vector< float > *arg2 = 0 ;
52263
52264   arg1 = (Dali::Vector< float > *)jarg1;
52265   arg2 = (Dali::Vector< float > *)jarg2;
52266   if (!arg2) {
52267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52268     return ;
52269   }
52270   {
52271     try {
52272       (arg1)->Swap(*arg2);
52273     } catch (std::out_of_range& e) {
52274       {
52275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52276       };
52277     } catch (std::exception& e) {
52278       {
52279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52280       };
52281     } catch (Dali::DaliException e) {
52282       {
52283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52284       };
52285     } catch (...) {
52286       {
52287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52288       };
52289     }
52290   }
52291
52292 }
52293
52294
52295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52296   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52297
52298   arg1 = (Dali::Vector< float > *)jarg1;
52299   {
52300     try {
52301       (arg1)->Clear();
52302     } catch (std::out_of_range& e) {
52303       {
52304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52305       };
52306     } catch (std::exception& e) {
52307       {
52308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52309       };
52310     } catch (Dali::DaliException e) {
52311       {
52312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52313       };
52314     } catch (...) {
52315       {
52316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52317       };
52318     }
52319   }
52320
52321 }
52322
52323
52324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52325   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52326
52327   arg1 = (Dali::Vector< float > *)jarg1;
52328   {
52329     try {
52330       (arg1)->Release();
52331     } catch (std::out_of_range& e) {
52332       {
52333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52334       };
52335     } catch (std::exception& e) {
52336       {
52337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52338       };
52339     } catch (Dali::DaliException e) {
52340       {
52341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52342       };
52343     } catch (...) {
52344       {
52345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52346       };
52347     }
52348   }
52349
52350 }
52351
52352
52353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52354   int jresult ;
52355   int result;
52356
52357   result = (int)Dali::Vector< unsigned char >::BaseType;
52358   jresult = (int)result;
52359   return jresult;
52360 }
52361
52362
52363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52364   void * jresult ;
52365   Dali::Vector< unsigned char > *result = 0 ;
52366
52367   {
52368     try {
52369       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52370     } catch (std::out_of_range& e) {
52371       {
52372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52373       };
52374     } catch (std::exception& e) {
52375       {
52376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52377       };
52378     } catch (Dali::DaliException e) {
52379       {
52380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52381       };
52382     } catch (...) {
52383       {
52384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52385       };
52386     }
52387   }
52388
52389   jresult = (void *)result;
52390   return jresult;
52391 }
52392
52393
52394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52395   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52396
52397   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52398   {
52399     try {
52400       delete arg1;
52401     } catch (std::out_of_range& e) {
52402       {
52403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52404       };
52405     } catch (std::exception& e) {
52406       {
52407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52408       };
52409     } catch (Dali::DaliException e) {
52410       {
52411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52412       };
52413     } catch (...) {
52414       {
52415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52416       };
52417     }
52418   }
52419
52420 }
52421
52422
52423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52424   void * jresult ;
52425   Dali::Vector< unsigned char > *arg1 = 0 ;
52426   Dali::Vector< unsigned char > *result = 0 ;
52427
52428   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52429   if (!arg1) {
52430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52431     return 0;
52432   }
52433   {
52434     try {
52435       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52436     } catch (std::out_of_range& e) {
52437       {
52438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52439       };
52440     } catch (std::exception& e) {
52441       {
52442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52443       };
52444     } catch (Dali::DaliException e) {
52445       {
52446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52447       };
52448     } catch (...) {
52449       {
52450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52451       };
52452     }
52453   }
52454
52455   jresult = (void *)result;
52456   return jresult;
52457 }
52458
52459
52460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52461   void * jresult ;
52462   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52463   Dali::Vector< unsigned char > *arg2 = 0 ;
52464   Dali::Vector< unsigned char > *result = 0 ;
52465
52466   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52467   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52468   if (!arg2) {
52469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52470     return 0;
52471   }
52472   {
52473     try {
52474       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52475     } catch (std::out_of_range& e) {
52476       {
52477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52478       };
52479     } catch (std::exception& e) {
52480       {
52481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52482       };
52483     } catch (Dali::DaliException e) {
52484       {
52485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52486       };
52487     } catch (...) {
52488       {
52489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52490       };
52491     }
52492   }
52493
52494   jresult = (void *)result;
52495   return jresult;
52496 }
52497
52498
52499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52500   void * jresult ;
52501   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52502   Dali::Vector< unsigned char >::Iterator result;
52503
52504   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52505   {
52506     try {
52507       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52508     } catch (std::out_of_range& e) {
52509       {
52510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52511       };
52512     } catch (std::exception& e) {
52513       {
52514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52515       };
52516     } catch (Dali::DaliException e) {
52517       {
52518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52519       };
52520     } catch (...) {
52521       {
52522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52523       };
52524     }
52525   }
52526
52527   jresult = (void *)result;
52528   return jresult;
52529 }
52530
52531
52532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52533   void * jresult ;
52534   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52535   Dali::Vector< unsigned char >::Iterator result;
52536
52537   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52538   {
52539     try {
52540       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52541     } catch (std::out_of_range& e) {
52542       {
52543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52544       };
52545     } catch (std::exception& e) {
52546       {
52547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52548       };
52549     } catch (Dali::DaliException e) {
52550       {
52551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52552       };
52553     } catch (...) {
52554       {
52555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52556       };
52557     }
52558   }
52559
52560   jresult = (void *)result;
52561   return jresult;
52562 }
52563
52564
52565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52566   void * jresult ;
52567   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52568   Dali::Vector< unsigned char >::SizeType arg2 ;
52569   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52570
52571   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52572   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52573   {
52574     try {
52575       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52576     } catch (std::out_of_range& e) {
52577       {
52578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52579       };
52580     } catch (std::exception& e) {
52581       {
52582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52583       };
52584     } catch (Dali::DaliException e) {
52585       {
52586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52587       };
52588     } catch (...) {
52589       {
52590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52591       };
52592     }
52593   }
52594
52595   jresult = (void *)result;
52596   return jresult;
52597 }
52598
52599
52600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52601   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52602   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52603   Dali::Vector< unsigned char >::ItemType temp2 ;
52604
52605   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52606   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52607   arg2 = &temp2;
52608   {
52609     try {
52610       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52611     } catch (std::out_of_range& e) {
52612       {
52613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52614       };
52615     } catch (std::exception& e) {
52616       {
52617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52618       };
52619     } catch (Dali::DaliException e) {
52620       {
52621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52622       };
52623     } catch (...) {
52624       {
52625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52626       };
52627     }
52628   }
52629
52630 }
52631
52632
52633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52634   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52635   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52636   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52637   Dali::Vector< unsigned char >::ItemType temp3 ;
52638
52639   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52640   arg2 = jarg2;
52641   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52642   arg3 = &temp3;
52643   {
52644     try {
52645       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52646     } catch (std::out_of_range& e) {
52647       {
52648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52649       };
52650     } catch (std::exception& e) {
52651       {
52652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52653       };
52654     } catch (Dali::DaliException e) {
52655       {
52656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52657       };
52658     } catch (...) {
52659       {
52660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52661       };
52662     }
52663   }
52664
52665
52666
52667 }
52668
52669
52670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52671   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52672   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52673   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52674   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52675
52676   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52677   arg2 = jarg2;
52678   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52679   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52680   {
52681     try {
52682       (arg1)->Insert(arg2,arg3,arg4);
52683     } catch (std::out_of_range& e) {
52684       {
52685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52686       };
52687     } catch (std::exception& e) {
52688       {
52689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52690       };
52691     } catch (Dali::DaliException e) {
52692       {
52693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52694       };
52695     } catch (...) {
52696       {
52697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52698       };
52699     }
52700   }
52701
52702
52703
52704 }
52705
52706
52707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52708   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52709   Dali::Vector< unsigned char >::SizeType arg2 ;
52710
52711   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52712   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52713   {
52714     try {
52715       (arg1)->Reserve(arg2);
52716     } catch (std::out_of_range& e) {
52717       {
52718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52719       };
52720     } catch (std::exception& e) {
52721       {
52722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52723       };
52724     } catch (Dali::DaliException e) {
52725       {
52726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52727       };
52728     } catch (...) {
52729       {
52730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52731       };
52732     }
52733   }
52734
52735 }
52736
52737
52738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52739   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52740   Dali::Vector< unsigned char >::SizeType arg2 ;
52741
52742   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52743   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52744   {
52745     try {
52746       (arg1)->Resize(arg2);
52747     } catch (std::out_of_range& e) {
52748       {
52749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52750       };
52751     } catch (std::exception& e) {
52752       {
52753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52754       };
52755     } catch (Dali::DaliException e) {
52756       {
52757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52758       };
52759     } catch (...) {
52760       {
52761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52762       };
52763     }
52764   }
52765
52766 }
52767
52768
52769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52770   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52771   Dali::Vector< unsigned char >::SizeType arg2 ;
52772   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52773   Dali::Vector< unsigned char >::ItemType temp3 ;
52774
52775   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52776   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52777   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52778   arg3 = &temp3;
52779   {
52780     try {
52781       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52782     } catch (std::out_of_range& e) {
52783       {
52784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52785       };
52786     } catch (std::exception& e) {
52787       {
52788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52789       };
52790     } catch (Dali::DaliException e) {
52791       {
52792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52793       };
52794     } catch (...) {
52795       {
52796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52797       };
52798     }
52799   }
52800
52801 }
52802
52803
52804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52805   void * jresult ;
52806   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52807   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52808   Dali::Vector< unsigned char >::Iterator result;
52809
52810   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52811   arg2 = jarg2;
52812   {
52813     try {
52814       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52815     } catch (std::out_of_range& e) {
52816       {
52817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52818       };
52819     } catch (std::exception& e) {
52820       {
52821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52822       };
52823     } catch (Dali::DaliException e) {
52824       {
52825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52826       };
52827     } catch (...) {
52828       {
52829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52830       };
52831     }
52832   }
52833
52834   jresult = (void *)result;
52835
52836
52837   return jresult;
52838 }
52839
52840
52841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52842   void * jresult ;
52843   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52844   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52845   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52846   Dali::Vector< unsigned char >::Iterator result;
52847
52848   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52849   arg2 = jarg2;
52850   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52851   {
52852     try {
52853       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52854     } catch (std::out_of_range& e) {
52855       {
52856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52857       };
52858     } catch (std::exception& e) {
52859       {
52860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52861       };
52862     } catch (Dali::DaliException e) {
52863       {
52864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52865       };
52866     } catch (...) {
52867       {
52868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52869       };
52870     }
52871   }
52872
52873   jresult = (void *)result;
52874
52875
52876   return jresult;
52877 }
52878
52879
52880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52881   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52882   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52883
52884   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52885   arg2 = jarg2;
52886   {
52887     try {
52888       (arg1)->Remove(arg2);
52889     } catch (std::out_of_range& e) {
52890       {
52891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52892       };
52893     } catch (std::exception& e) {
52894       {
52895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52896       };
52897     } catch (Dali::DaliException e) {
52898       {
52899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52900       };
52901     } catch (...) {
52902       {
52903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52904       };
52905     }
52906   }
52907
52908
52909
52910 }
52911
52912
52913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52914   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52915   Dali::Vector< unsigned char > *arg2 = 0 ;
52916
52917   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52918   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52919   if (!arg2) {
52920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52921     return ;
52922   }
52923   {
52924     try {
52925       (arg1)->Swap(*arg2);
52926     } catch (std::out_of_range& e) {
52927       {
52928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52929       };
52930     } catch (std::exception& e) {
52931       {
52932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52933       };
52934     } catch (Dali::DaliException e) {
52935       {
52936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52937       };
52938     } catch (...) {
52939       {
52940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52941       };
52942     }
52943   }
52944
52945 }
52946
52947
52948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52949   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52950
52951   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52952   {
52953     try {
52954       (arg1)->Clear();
52955     } catch (std::out_of_range& e) {
52956       {
52957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52958       };
52959     } catch (std::exception& e) {
52960       {
52961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52962       };
52963     } catch (Dali::DaliException e) {
52964       {
52965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52966       };
52967     } catch (...) {
52968       {
52969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52970       };
52971     }
52972   }
52973
52974 }
52975
52976
52977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52978   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52979
52980   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52981   {
52982     try {
52983       (arg1)->Release();
52984     } catch (std::out_of_range& e) {
52985       {
52986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52987       };
52988     } catch (std::exception& e) {
52989       {
52990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52991       };
52992     } catch (Dali::DaliException e) {
52993       {
52994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52995       };
52996     } catch (...) {
52997       {
52998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52999       };
53000     }
53001   }
53002
53003 }
53004
53005
53006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53007   int jresult ;
53008   int result;
53009
53010   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53011   jresult = (int)result;
53012   return jresult;
53013 }
53014
53015
53016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53017   void * jresult ;
53018   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53019
53020   {
53021     try {
53022       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53023     } catch (std::out_of_range& e) {
53024       {
53025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53026       };
53027     } catch (std::exception& e) {
53028       {
53029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53030       };
53031     } catch (Dali::DaliException e) {
53032       {
53033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53034       };
53035     } catch (...) {
53036       {
53037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53038       };
53039     }
53040   }
53041
53042   jresult = (void *)result;
53043   return jresult;
53044 }
53045
53046
53047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53048   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53049
53050   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53051   {
53052     try {
53053       delete arg1;
53054     } catch (std::out_of_range& e) {
53055       {
53056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53057       };
53058     } catch (std::exception& e) {
53059       {
53060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53061       };
53062     } catch (Dali::DaliException e) {
53063       {
53064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53065       };
53066     } catch (...) {
53067       {
53068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53069       };
53070     }
53071   }
53072
53073 }
53074
53075
53076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53077   void * jresult ;
53078   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53079   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53080
53081   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53082   if (!arg1) {
53083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53084     return 0;
53085   }
53086   {
53087     try {
53088       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53089     } catch (std::out_of_range& e) {
53090       {
53091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53092       };
53093     } catch (std::exception& e) {
53094       {
53095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53096       };
53097     } catch (Dali::DaliException e) {
53098       {
53099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53100       };
53101     } catch (...) {
53102       {
53103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53104       };
53105     }
53106   }
53107
53108   jresult = (void *)result;
53109   return jresult;
53110 }
53111
53112
53113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53114   void * jresult ;
53115   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53116   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53117   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53118
53119   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53120   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53121   if (!arg2) {
53122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53123     return 0;
53124   }
53125   {
53126     try {
53127       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53128     } catch (std::out_of_range& e) {
53129       {
53130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53131       };
53132     } catch (std::exception& e) {
53133       {
53134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53135       };
53136     } catch (Dali::DaliException e) {
53137       {
53138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53139       };
53140     } catch (...) {
53141       {
53142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53143       };
53144     }
53145   }
53146
53147   jresult = (void *)result;
53148   return jresult;
53149 }
53150
53151
53152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53153   void * jresult ;
53154   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53155   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53156
53157   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53158   {
53159     try {
53160       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53161     } catch (std::out_of_range& e) {
53162       {
53163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53164       };
53165     } catch (std::exception& e) {
53166       {
53167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53168       };
53169     } catch (Dali::DaliException e) {
53170       {
53171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53172       };
53173     } catch (...) {
53174       {
53175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53176       };
53177     }
53178   }
53179
53180   jresult = (void *)result;
53181   return jresult;
53182 }
53183
53184
53185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53186   void * jresult ;
53187   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53188   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53189
53190   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53191   {
53192     try {
53193       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53194     } catch (std::out_of_range& e) {
53195       {
53196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53197       };
53198     } catch (std::exception& e) {
53199       {
53200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53201       };
53202     } catch (Dali::DaliException e) {
53203       {
53204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53205       };
53206     } catch (...) {
53207       {
53208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53209       };
53210     }
53211   }
53212
53213   jresult = (void *)result;
53214   return jresult;
53215 }
53216
53217
53218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53219   void * jresult ;
53220   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53221   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53222   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53223
53224   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53225   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53226   {
53227     try {
53228       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53229     } catch (std::out_of_range& e) {
53230       {
53231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53232       };
53233     } catch (std::exception& e) {
53234       {
53235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53236       };
53237     } catch (Dali::DaliException e) {
53238       {
53239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53240       };
53241     } catch (...) {
53242       {
53243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53244       };
53245     }
53246   }
53247
53248   jresult = (void *)result;
53249   return jresult;
53250 }
53251
53252
53253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53254   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53255   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53256
53257   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53258   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53259   if (!arg2) {
53260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53261     return ;
53262   }
53263   {
53264     try {
53265       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53266     } catch (std::out_of_range& e) {
53267       {
53268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53269       };
53270     } catch (std::exception& e) {
53271       {
53272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53273       };
53274     } catch (Dali::DaliException e) {
53275       {
53276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53277       };
53278     } catch (...) {
53279       {
53280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53281       };
53282     }
53283   }
53284
53285 }
53286
53287
53288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53289   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53290   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53291   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53292
53293   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53294   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53295   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53296   if (!arg3) {
53297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53298     return ;
53299   }
53300   {
53301     try {
53302       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53303     } catch (std::out_of_range& e) {
53304       {
53305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53306       };
53307     } catch (std::exception& e) {
53308       {
53309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53310       };
53311     } catch (Dali::DaliException e) {
53312       {
53313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53314       };
53315     } catch (...) {
53316       {
53317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53318       };
53319     }
53320   }
53321
53322 }
53323
53324
53325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53326   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53327   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53328   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53329   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53330
53331   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53332   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53333   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53334   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53335   {
53336     try {
53337       (arg1)->Insert(arg2,arg3,arg4);
53338     } catch (std::out_of_range& e) {
53339       {
53340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53341       };
53342     } catch (std::exception& e) {
53343       {
53344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53345       };
53346     } catch (Dali::DaliException e) {
53347       {
53348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53349       };
53350     } catch (...) {
53351       {
53352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53353       };
53354     }
53355   }
53356
53357 }
53358
53359
53360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53361   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53362   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53363
53364   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53365   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53366   {
53367     try {
53368       (arg1)->Reserve(arg2);
53369     } catch (std::out_of_range& e) {
53370       {
53371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53372       };
53373     } catch (std::exception& e) {
53374       {
53375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53376       };
53377     } catch (Dali::DaliException e) {
53378       {
53379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53380       };
53381     } catch (...) {
53382       {
53383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53384       };
53385     }
53386   }
53387
53388 }
53389
53390
53391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53392   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53393   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53394
53395   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53396   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53397   {
53398     try {
53399       (arg1)->Resize(arg2);
53400     } catch (std::out_of_range& e) {
53401       {
53402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53403       };
53404     } catch (std::exception& e) {
53405       {
53406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53407       };
53408     } catch (Dali::DaliException e) {
53409       {
53410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53411       };
53412     } catch (...) {
53413       {
53414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53415       };
53416     }
53417   }
53418
53419 }
53420
53421
53422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53423   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53424   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53425   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53426
53427   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53428   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53429   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53430   if (!arg3) {
53431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53432     return ;
53433   }
53434   {
53435     try {
53436       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53437     } catch (std::out_of_range& e) {
53438       {
53439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53440       };
53441     } catch (std::exception& e) {
53442       {
53443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53444       };
53445     } catch (Dali::DaliException e) {
53446       {
53447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53448       };
53449     } catch (...) {
53450       {
53451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53452       };
53453     }
53454   }
53455
53456 }
53457
53458
53459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53460   void * jresult ;
53461   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53462   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53463   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53464
53465   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53466   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53467   {
53468     try {
53469       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53470     } catch (std::out_of_range& e) {
53471       {
53472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53473       };
53474     } catch (std::exception& e) {
53475       {
53476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53477       };
53478     } catch (Dali::DaliException e) {
53479       {
53480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53481       };
53482     } catch (...) {
53483       {
53484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53485       };
53486     }
53487   }
53488
53489   jresult = (void *)result;
53490   return jresult;
53491 }
53492
53493
53494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53495   void * jresult ;
53496   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53497   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53498   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53499   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53500
53501   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53502   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53503   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53504   {
53505     try {
53506       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53507     } catch (std::out_of_range& e) {
53508       {
53509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53510       };
53511     } catch (std::exception& e) {
53512       {
53513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53514       };
53515     } catch (Dali::DaliException e) {
53516       {
53517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53518       };
53519     } catch (...) {
53520       {
53521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53522       };
53523     }
53524   }
53525
53526   jresult = (void *)result;
53527   return jresult;
53528 }
53529
53530
53531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53532   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53533   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53534
53535   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53536   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53537   {
53538     try {
53539       (arg1)->Remove(arg2);
53540     } catch (std::out_of_range& e) {
53541       {
53542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53543       };
53544     } catch (std::exception& e) {
53545       {
53546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53547       };
53548     } catch (Dali::DaliException e) {
53549       {
53550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53551       };
53552     } catch (...) {
53553       {
53554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53555       };
53556     }
53557   }
53558
53559 }
53560
53561
53562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53563   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53564   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53565
53566   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53567   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53568   if (!arg2) {
53569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53570     return ;
53571   }
53572   {
53573     try {
53574       (arg1)->Swap(*arg2);
53575     } catch (std::out_of_range& e) {
53576       {
53577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53578       };
53579     } catch (std::exception& e) {
53580       {
53581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53582       };
53583     } catch (Dali::DaliException e) {
53584       {
53585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53586       };
53587     } catch (...) {
53588       {
53589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53590       };
53591     }
53592   }
53593
53594 }
53595
53596
53597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53598   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53599
53600   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53601   {
53602     try {
53603       (arg1)->Clear();
53604     } catch (std::out_of_range& e) {
53605       {
53606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53607       };
53608     } catch (std::exception& e) {
53609       {
53610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53611       };
53612     } catch (Dali::DaliException e) {
53613       {
53614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53615       };
53616     } catch (...) {
53617       {
53618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53619       };
53620     }
53621   }
53622
53623 }
53624
53625
53626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53627   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53628
53629   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53630   {
53631     try {
53632       (arg1)->Release();
53633     } catch (std::out_of_range& e) {
53634       {
53635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53636       };
53637     } catch (std::exception& e) {
53638       {
53639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53640       };
53641     } catch (Dali::DaliException e) {
53642       {
53643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53644       };
53645     } catch (...) {
53646       {
53647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53648       };
53649     }
53650   }
53651
53652 }
53653
53654
53655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53656   void * jresult ;
53657   Dali::Signal< void () > *result = 0 ;
53658
53659   {
53660     try {
53661       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53662     } catch (std::out_of_range& e) {
53663       {
53664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53665       };
53666     } catch (std::exception& e) {
53667       {
53668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53669       };
53670     } catch (Dali::DaliException e) {
53671       {
53672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53673       };
53674     } catch (...) {
53675       {
53676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53677       };
53678     }
53679   }
53680
53681   jresult = (void *)result;
53682   return jresult;
53683 }
53684
53685
53686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53687   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53688
53689   arg1 = (Dali::Signal< void () > *)jarg1;
53690   {
53691     try {
53692       delete arg1;
53693     } catch (std::out_of_range& e) {
53694       {
53695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53696       };
53697     } catch (std::exception& e) {
53698       {
53699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53700       };
53701     } catch (Dali::DaliException e) {
53702       {
53703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53704       };
53705     } catch (...) {
53706       {
53707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53708       };
53709     }
53710   }
53711
53712 }
53713
53714
53715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53716   unsigned int jresult ;
53717   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53718   bool result;
53719
53720   arg1 = (Dali::Signal< void () > *)jarg1;
53721   {
53722     try {
53723       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53724     } catch (std::out_of_range& e) {
53725       {
53726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53727       };
53728     } catch (std::exception& e) {
53729       {
53730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53731       };
53732     } catch (Dali::DaliException e) {
53733       {
53734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53735       };
53736     } catch (...) {
53737       {
53738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53739       };
53740     }
53741   }
53742
53743   jresult = result;
53744   return jresult;
53745 }
53746
53747
53748 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53749   unsigned long jresult ;
53750   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53751   std::size_t result;
53752
53753   arg1 = (Dali::Signal< void () > *)jarg1;
53754   {
53755     try {
53756       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53757     } catch (std::out_of_range& e) {
53758       {
53759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53760       };
53761     } catch (std::exception& e) {
53762       {
53763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53764       };
53765     } catch (Dali::DaliException e) {
53766       {
53767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53768       };
53769     } catch (...) {
53770       {
53771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53772       };
53773     }
53774   }
53775
53776   jresult = (unsigned long)result;
53777   return jresult;
53778 }
53779
53780
53781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53782   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53783   void (*arg2)() = (void (*)()) 0 ;
53784
53785   arg1 = (Dali::Signal< void () > *)jarg1;
53786   arg2 = (void (*)())jarg2;
53787   {
53788     try {
53789       (arg1)->Connect(arg2);
53790     } catch (std::out_of_range& e) {
53791       {
53792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53793       };
53794     } catch (std::exception& e) {
53795       {
53796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53797       };
53798     } catch (Dali::DaliException e) {
53799       {
53800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53801       };
53802     } catch (...) {
53803       {
53804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53805       };
53806     }
53807   }
53808
53809 }
53810
53811
53812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53813   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53814   void (*arg2)() = (void (*)()) 0 ;
53815
53816   arg1 = (Dali::Signal< void () > *)jarg1;
53817   arg2 = (void (*)())jarg2;
53818   {
53819     try {
53820       (arg1)->Disconnect(arg2);
53821     } catch (std::out_of_range& e) {
53822       {
53823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53824       };
53825     } catch (std::exception& e) {
53826       {
53827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53828       };
53829     } catch (Dali::DaliException e) {
53830       {
53831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53832       };
53833     } catch (...) {
53834       {
53835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53836       };
53837     }
53838   }
53839
53840 }
53841
53842
53843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53844   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53845   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53846   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53847
53848   arg1 = (Dali::Signal< void () > *)jarg1;
53849   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53850   arg3 = (Dali::FunctorDelegate *)jarg3;
53851   {
53852     try {
53853       (arg1)->Connect(arg2,arg3);
53854     } catch (std::out_of_range& e) {
53855       {
53856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53857       };
53858     } catch (std::exception& e) {
53859       {
53860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53861       };
53862     } catch (Dali::DaliException e) {
53863       {
53864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53865       };
53866     } catch (...) {
53867       {
53868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53869       };
53870     }
53871   }
53872
53873 }
53874
53875
53876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53877   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53878
53879   arg1 = (Dali::Signal< void () > *)jarg1;
53880   {
53881     try {
53882       (arg1)->Emit();
53883     } catch (std::out_of_range& e) {
53884       {
53885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53886       };
53887     } catch (std::exception& e) {
53888       {
53889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53890       };
53891     } catch (Dali::DaliException e) {
53892       {
53893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53894       };
53895     } catch (...) {
53896       {
53897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53898       };
53899     }
53900   }
53901
53902 }
53903
53904
53905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53906   unsigned int jresult ;
53907   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53908   bool result;
53909
53910   arg1 = (Dali::Signal< void (float) > *)jarg1;
53911   {
53912     try {
53913       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53914     } catch (std::out_of_range& e) {
53915       {
53916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53917       };
53918     } catch (std::exception& e) {
53919       {
53920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53921       };
53922     } catch (Dali::DaliException e) {
53923       {
53924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53925       };
53926     } catch (...) {
53927       {
53928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53929       };
53930     }
53931   }
53932
53933   jresult = result;
53934   return jresult;
53935 }
53936
53937
53938 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53939   unsigned long jresult ;
53940   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53941   std::size_t result;
53942
53943   arg1 = (Dali::Signal< void (float) > *)jarg1;
53944   {
53945     try {
53946       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53947     } catch (std::out_of_range& e) {
53948       {
53949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53950       };
53951     } catch (std::exception& e) {
53952       {
53953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53954       };
53955     } catch (Dali::DaliException e) {
53956       {
53957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53958       };
53959     } catch (...) {
53960       {
53961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53962       };
53963     }
53964   }
53965
53966   jresult = (unsigned long)result;
53967   return jresult;
53968 }
53969
53970
53971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53972   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53973   void (*arg2)(float) = (void (*)(float)) 0 ;
53974
53975   arg1 = (Dali::Signal< void (float) > *)jarg1;
53976   arg2 = (void (*)(float))jarg2;
53977   {
53978     try {
53979       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53980     } catch (std::out_of_range& e) {
53981       {
53982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53983       };
53984     } catch (std::exception& e) {
53985       {
53986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53987       };
53988     } catch (Dali::DaliException e) {
53989       {
53990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53991       };
53992     } catch (...) {
53993       {
53994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53995       };
53996     }
53997   }
53998
53999 }
54000
54001
54002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54003   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54004   void (*arg2)(float) = (void (*)(float)) 0 ;
54005
54006   arg1 = (Dali::Signal< void (float) > *)jarg1;
54007   arg2 = (void (*)(float))jarg2;
54008   {
54009     try {
54010       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54011     } catch (std::out_of_range& e) {
54012       {
54013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54014       };
54015     } catch (std::exception& e) {
54016       {
54017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54018       };
54019     } catch (Dali::DaliException e) {
54020       {
54021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54022       };
54023     } catch (...) {
54024       {
54025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54026       };
54027     }
54028   }
54029
54030 }
54031
54032
54033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54034   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54035   float arg2 ;
54036
54037   arg1 = (Dali::Signal< void (float) > *)jarg1;
54038   arg2 = (float)jarg2;
54039   {
54040     try {
54041       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54042     } catch (std::out_of_range& e) {
54043       {
54044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54045       };
54046     } catch (std::exception& e) {
54047       {
54048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54049       };
54050     } catch (Dali::DaliException e) {
54051       {
54052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54053       };
54054     } catch (...) {
54055       {
54056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54057       };
54058     }
54059   }
54060
54061 }
54062
54063
54064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54065   void * jresult ;
54066   Dali::Signal< void (float) > *result = 0 ;
54067
54068   {
54069     try {
54070       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54071     } catch (std::out_of_range& e) {
54072       {
54073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54074       };
54075     } catch (std::exception& e) {
54076       {
54077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54078       };
54079     } catch (Dali::DaliException e) {
54080       {
54081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54082       };
54083     } catch (...) {
54084       {
54085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54086       };
54087     }
54088   }
54089
54090   jresult = (void *)result;
54091   return jresult;
54092 }
54093
54094
54095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54096   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54097
54098   arg1 = (Dali::Signal< void (float) > *)jarg1;
54099   {
54100     try {
54101       delete arg1;
54102     } catch (std::out_of_range& e) {
54103       {
54104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54105       };
54106     } catch (std::exception& e) {
54107       {
54108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54109       };
54110     } catch (Dali::DaliException e) {
54111       {
54112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54113       };
54114     } catch (...) {
54115       {
54116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54117       };
54118     }
54119   }
54120
54121 }
54122
54123
54124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54125   unsigned int jresult ;
54126   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54127   bool result;
54128
54129   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54130   {
54131     try {
54132       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54133     } catch (std::out_of_range& e) {
54134       {
54135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54136       };
54137     } catch (std::exception& e) {
54138       {
54139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54140       };
54141     } catch (Dali::DaliException e) {
54142       {
54143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54144       };
54145     } catch (...) {
54146       {
54147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54148       };
54149     }
54150   }
54151
54152   jresult = result;
54153   return jresult;
54154 }
54155
54156
54157 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54158   unsigned long jresult ;
54159   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54160   std::size_t result;
54161
54162   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54163   {
54164     try {
54165       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54166     } catch (std::out_of_range& e) {
54167       {
54168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54169       };
54170     } catch (std::exception& e) {
54171       {
54172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54173       };
54174     } catch (Dali::DaliException e) {
54175       {
54176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54177       };
54178     } catch (...) {
54179       {
54180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54181       };
54182     }
54183   }
54184
54185   jresult = (unsigned long)result;
54186   return jresult;
54187 }
54188
54189
54190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54191   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54192   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54193
54194   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54195   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54196   {
54197     try {
54198       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54199     } catch (std::out_of_range& e) {
54200       {
54201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54202       };
54203     } catch (std::exception& e) {
54204       {
54205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54206       };
54207     } catch (Dali::DaliException e) {
54208       {
54209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54210       };
54211     } catch (...) {
54212       {
54213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54214       };
54215     }
54216   }
54217
54218 }
54219
54220
54221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54222   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54223   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54224
54225   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54226   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54227   {
54228     try {
54229       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54230     } catch (std::out_of_range& e) {
54231       {
54232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54233       };
54234     } catch (std::exception& e) {
54235       {
54236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54237       };
54238     } catch (Dali::DaliException e) {
54239       {
54240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54241       };
54242     } catch (...) {
54243       {
54244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54245       };
54246     }
54247   }
54248
54249 }
54250
54251
54252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54253   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54254   Dali::BaseHandle arg2 ;
54255   Dali::BaseHandle *argp2 ;
54256
54257   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54258   argp2 = (Dali::BaseHandle *)jarg2;
54259   if (!argp2) {
54260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54261     return ;
54262   }
54263   arg2 = *argp2;
54264   {
54265     try {
54266       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54267     } catch (std::out_of_range& e) {
54268       {
54269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54270       };
54271     } catch (std::exception& e) {
54272       {
54273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54274       };
54275     } catch (Dali::DaliException e) {
54276       {
54277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54278       };
54279     } catch (...) {
54280       {
54281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54282       };
54283     }
54284   }
54285
54286 }
54287
54288
54289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54290   void * jresult ;
54291   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54292
54293   {
54294     try {
54295       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54296     } catch (std::out_of_range& e) {
54297       {
54298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54299       };
54300     } catch (std::exception& e) {
54301       {
54302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54303       };
54304     } catch (Dali::DaliException e) {
54305       {
54306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54307       };
54308     } catch (...) {
54309       {
54310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54311       };
54312     }
54313   }
54314
54315   jresult = (void *)result;
54316   return jresult;
54317 }
54318
54319
54320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54321   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54322
54323   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54324   {
54325     try {
54326       delete arg1;
54327     } catch (std::out_of_range& e) {
54328       {
54329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54330       };
54331     } catch (std::exception& e) {
54332       {
54333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54334       };
54335     } catch (Dali::DaliException e) {
54336       {
54337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54338       };
54339     } catch (...) {
54340       {
54341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54342       };
54343     }
54344   }
54345
54346 }
54347
54348
54349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54350   unsigned int jresult ;
54351   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54352   bool result;
54353
54354   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54355   {
54356     try {
54357       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54358     } catch (std::out_of_range& e) {
54359       {
54360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54361       };
54362     } catch (std::exception& e) {
54363       {
54364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54365       };
54366     } catch (Dali::DaliException e) {
54367       {
54368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54369       };
54370     } catch (...) {
54371       {
54372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54373       };
54374     }
54375   }
54376
54377   jresult = result;
54378   return jresult;
54379 }
54380
54381
54382 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54383   unsigned long jresult ;
54384   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54385   std::size_t result;
54386
54387   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54388   {
54389     try {
54390       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54391     } catch (std::out_of_range& e) {
54392       {
54393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54394       };
54395     } catch (std::exception& e) {
54396       {
54397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54398       };
54399     } catch (Dali::DaliException e) {
54400       {
54401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54402       };
54403     } catch (...) {
54404       {
54405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54406       };
54407     }
54408   }
54409
54410   jresult = (unsigned long)result;
54411   return jresult;
54412 }
54413
54414
54415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54416   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54417   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54418
54419   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54420   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54421   {
54422     try {
54423       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54424     } catch (std::out_of_range& e) {
54425       {
54426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54427       };
54428     } catch (std::exception& e) {
54429       {
54430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54431       };
54432     } catch (Dali::DaliException e) {
54433       {
54434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54435       };
54436     } catch (...) {
54437       {
54438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54439       };
54440     }
54441   }
54442
54443 }
54444
54445
54446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54447   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54448   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54449
54450   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54451   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54452   {
54453     try {
54454       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54455     } catch (std::out_of_range& e) {
54456       {
54457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54458       };
54459     } catch (std::exception& e) {
54460       {
54461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54462       };
54463     } catch (Dali::DaliException e) {
54464       {
54465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54466       };
54467     } catch (...) {
54468       {
54469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54470       };
54471     }
54472   }
54473
54474 }
54475
54476
54477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54478   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54479   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54480
54481   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54482   arg2 = (Dali::RefObject *)jarg2;
54483   {
54484     try {
54485       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54486     } catch (std::out_of_range& e) {
54487       {
54488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54489       };
54490     } catch (std::exception& e) {
54491       {
54492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54493       };
54494     } catch (Dali::DaliException e) {
54495       {
54496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54497       };
54498     } catch (...) {
54499       {
54500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54501       };
54502     }
54503   }
54504
54505 }
54506
54507
54508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54509   void * jresult ;
54510   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54511
54512   {
54513     try {
54514       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54515     } catch (std::out_of_range& e) {
54516       {
54517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54518       };
54519     } catch (std::exception& e) {
54520       {
54521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54522       };
54523     } catch (Dali::DaliException e) {
54524       {
54525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54526       };
54527     } catch (...) {
54528       {
54529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54530       };
54531     }
54532   }
54533
54534   jresult = (void *)result;
54535   return jresult;
54536 }
54537
54538
54539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54540   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54541
54542   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54543   {
54544     try {
54545       delete arg1;
54546     } catch (std::out_of_range& e) {
54547       {
54548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54549       };
54550     } catch (std::exception& e) {
54551       {
54552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54553       };
54554     } catch (Dali::DaliException e) {
54555       {
54556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54557       };
54558     } catch (...) {
54559       {
54560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54561       };
54562     }
54563   }
54564
54565 }
54566
54567
54568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54569   unsigned int jresult ;
54570   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54571   bool result;
54572
54573   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54574   {
54575     try {
54576       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54577     } catch (std::out_of_range& e) {
54578       {
54579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54580       };
54581     } catch (std::exception& e) {
54582       {
54583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54584       };
54585     } catch (Dali::DaliException e) {
54586       {
54587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54588       };
54589     } catch (...) {
54590       {
54591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54592       };
54593     }
54594   }
54595
54596   jresult = result;
54597   return jresult;
54598 }
54599
54600
54601 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54602   unsigned long jresult ;
54603   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54604   std::size_t result;
54605
54606   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54607   {
54608     try {
54609       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54610     } catch (std::out_of_range& e) {
54611       {
54612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54613       };
54614     } catch (std::exception& e) {
54615       {
54616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54617       };
54618     } catch (Dali::DaliException e) {
54619       {
54620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54621       };
54622     } catch (...) {
54623       {
54624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54625       };
54626     }
54627   }
54628
54629   jresult = (unsigned long)result;
54630   return jresult;
54631 }
54632
54633
54634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54635   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54636   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54637
54638   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54639   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54640   {
54641     try {
54642       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54643     } catch (std::out_of_range& e) {
54644       {
54645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54646       };
54647     } catch (std::exception& e) {
54648       {
54649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54650       };
54651     } catch (Dali::DaliException e) {
54652       {
54653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54654       };
54655     } catch (...) {
54656       {
54657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54658       };
54659     }
54660   }
54661
54662 }
54663
54664
54665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54666   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54667   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54668
54669   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54670   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54671   {
54672     try {
54673       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54674     } catch (std::out_of_range& e) {
54675       {
54676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54677       };
54678     } catch (std::exception& e) {
54679       {
54680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54681       };
54682     } catch (Dali::DaliException e) {
54683       {
54684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54685       };
54686     } catch (...) {
54687       {
54688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54689       };
54690     }
54691   }
54692
54693 }
54694
54695
54696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54697   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54698   Dali::PropertyNotification *arg2 = 0 ;
54699
54700   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54701   arg2 = (Dali::PropertyNotification *)jarg2;
54702   if (!arg2) {
54703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54704     return ;
54705   }
54706   {
54707     try {
54708       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54709     } catch (std::out_of_range& e) {
54710       {
54711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54712       };
54713     } catch (std::exception& e) {
54714       {
54715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54716       };
54717     } catch (Dali::DaliException e) {
54718       {
54719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54720       };
54721     } catch (...) {
54722       {
54723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54724       };
54725     }
54726   }
54727
54728 }
54729
54730
54731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54732   void * jresult ;
54733   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54734
54735   {
54736     try {
54737       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54738     } catch (std::out_of_range& e) {
54739       {
54740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54741       };
54742     } catch (std::exception& e) {
54743       {
54744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54745       };
54746     } catch (Dali::DaliException e) {
54747       {
54748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54749       };
54750     } catch (...) {
54751       {
54752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54753       };
54754     }
54755   }
54756
54757   jresult = (void *)result;
54758   return jresult;
54759 }
54760
54761
54762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54763   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54764
54765   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54766   {
54767     try {
54768       delete arg1;
54769     } catch (std::out_of_range& e) {
54770       {
54771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54772       };
54773     } catch (std::exception& e) {
54774       {
54775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54776       };
54777     } catch (Dali::DaliException e) {
54778       {
54779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54780       };
54781     } catch (...) {
54782       {
54783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54784       };
54785     }
54786   }
54787
54788 }
54789
54790
54791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54792   unsigned int jresult ;
54793   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54794   bool result;
54795
54796   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54797   {
54798     try {
54799       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54800     } catch (std::out_of_range& e) {
54801       {
54802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54803       };
54804     } catch (std::exception& e) {
54805       {
54806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54807       };
54808     } catch (Dali::DaliException e) {
54809       {
54810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54811       };
54812     } catch (...) {
54813       {
54814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54815       };
54816     }
54817   }
54818
54819   jresult = result;
54820   return jresult;
54821 }
54822
54823
54824 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54825   unsigned long jresult ;
54826   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54827   std::size_t result;
54828
54829   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54830   {
54831     try {
54832       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54833     } catch (std::out_of_range& e) {
54834       {
54835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54836       };
54837     } catch (std::exception& e) {
54838       {
54839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54840       };
54841     } catch (Dali::DaliException e) {
54842       {
54843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54844       };
54845     } catch (...) {
54846       {
54847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54848       };
54849     }
54850   }
54851
54852   jresult = (unsigned long)result;
54853   return jresult;
54854 }
54855
54856
54857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54858   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54859   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54860
54861   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54862   arg2 = (void (*)(Dali::Image))jarg2;
54863   {
54864     try {
54865       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54866     } catch (std::out_of_range& e) {
54867       {
54868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54869       };
54870     } catch (std::exception& e) {
54871       {
54872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54873       };
54874     } catch (Dali::DaliException e) {
54875       {
54876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54877       };
54878     } catch (...) {
54879       {
54880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54881       };
54882     }
54883   }
54884
54885 }
54886
54887
54888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54889   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54890   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54891
54892   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54893   arg2 = (void (*)(Dali::Image))jarg2;
54894   {
54895     try {
54896       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54897     } catch (std::out_of_range& e) {
54898       {
54899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54900       };
54901     } catch (std::exception& e) {
54902       {
54903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54904       };
54905     } catch (Dali::DaliException e) {
54906       {
54907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54908       };
54909     } catch (...) {
54910       {
54911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54912       };
54913     }
54914   }
54915
54916 }
54917
54918
54919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54920   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54921   Dali::Image arg2 ;
54922   Dali::Image *argp2 ;
54923
54924   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54925   argp2 = (Dali::Image *)jarg2;
54926   if (!argp2) {
54927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54928     return ;
54929   }
54930   arg2 = *argp2;
54931   {
54932     try {
54933       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54934     } catch (std::out_of_range& e) {
54935       {
54936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54937       };
54938     } catch (std::exception& e) {
54939       {
54940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54941       };
54942     } catch (Dali::DaliException e) {
54943       {
54944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54945       };
54946     } catch (...) {
54947       {
54948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54949       };
54950     }
54951   }
54952
54953 }
54954
54955
54956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54957   void * jresult ;
54958   Dali::Signal< void (Dali::Image) > *result = 0 ;
54959
54960   {
54961     try {
54962       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54963     } catch (std::out_of_range& e) {
54964       {
54965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54966       };
54967     } catch (std::exception& e) {
54968       {
54969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54970       };
54971     } catch (Dali::DaliException e) {
54972       {
54973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54974       };
54975     } catch (...) {
54976       {
54977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54978       };
54979     }
54980   }
54981
54982   jresult = (void *)result;
54983   return jresult;
54984 }
54985
54986
54987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54988   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54989
54990   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54991   {
54992     try {
54993       delete arg1;
54994     } catch (std::out_of_range& e) {
54995       {
54996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54997       };
54998     } catch (std::exception& e) {
54999       {
55000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55001       };
55002     } catch (Dali::DaliException e) {
55003       {
55004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55005       };
55006     } catch (...) {
55007       {
55008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55009       };
55010     }
55011   }
55012
55013 }
55014
55015
55016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55017   void * jresult ;
55018   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55019
55020   {
55021     try {
55022       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55023     } catch (std::out_of_range& e) {
55024       {
55025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55026       };
55027     } catch (std::exception& e) {
55028       {
55029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55030       };
55031     } catch (Dali::DaliException e) {
55032       {
55033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55034       };
55035     } catch (...) {
55036       {
55037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55038       };
55039     }
55040   }
55041
55042   jresult = (void *)result;
55043   return jresult;
55044 }
55045
55046
55047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55048   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55049
55050   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55051   {
55052     try {
55053       delete arg1;
55054     } catch (std::out_of_range& e) {
55055       {
55056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55057       };
55058     } catch (std::exception& e) {
55059       {
55060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55061       };
55062     } catch (Dali::DaliException e) {
55063       {
55064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55065       };
55066     } catch (...) {
55067       {
55068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55069       };
55070     }
55071   }
55072
55073 }
55074
55075
55076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55077   unsigned int jresult ;
55078   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55079   bool result;
55080
55081   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55082   {
55083     try {
55084       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);
55085     } catch (std::out_of_range& e) {
55086       {
55087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55088       };
55089     } catch (std::exception& e) {
55090       {
55091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55092       };
55093     } catch (Dali::DaliException e) {
55094       {
55095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55096       };
55097     } catch (...) {
55098       {
55099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55100       };
55101     }
55102   }
55103
55104   jresult = result;
55105   return jresult;
55106 }
55107
55108
55109 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55110   unsigned long jresult ;
55111   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55112   std::size_t result;
55113
55114   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55115   {
55116     try {
55117       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);
55118     } catch (std::out_of_range& e) {
55119       {
55120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55121       };
55122     } catch (std::exception& e) {
55123       {
55124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55125       };
55126     } catch (Dali::DaliException e) {
55127       {
55128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55129       };
55130     } catch (...) {
55131       {
55132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55133       };
55134     }
55135   }
55136
55137   jresult = (unsigned long)result;
55138   return jresult;
55139 }
55140
55141
55142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55143   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55144   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55145
55146   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55147   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55148   {
55149     try {
55150       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55151     } catch (std::out_of_range& e) {
55152       {
55153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55154       };
55155     } catch (std::exception& e) {
55156       {
55157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55158       };
55159     } catch (Dali::DaliException e) {
55160       {
55161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55162       };
55163     } catch (...) {
55164       {
55165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55166       };
55167     }
55168   }
55169
55170 }
55171
55172
55173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55174   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55175   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55176
55177   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55178   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55179   {
55180     try {
55181       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55182     } catch (std::out_of_range& e) {
55183       {
55184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55185       };
55186     } catch (std::exception& e) {
55187       {
55188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55189       };
55190     } catch (Dali::DaliException e) {
55191       {
55192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55193       };
55194     } catch (...) {
55195       {
55196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55197       };
55198     }
55199   }
55200
55201 }
55202
55203
55204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55205   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55206   Dali::Actor arg2 ;
55207   Dali::LongPressGesture *arg3 = 0 ;
55208   Dali::Actor *argp2 ;
55209
55210   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55211   argp2 = (Dali::Actor *)jarg2;
55212   if (!argp2) {
55213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55214     return ;
55215   }
55216   arg2 = *argp2;
55217   arg3 = (Dali::LongPressGesture *)jarg3;
55218   if (!arg3) {
55219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55220     return ;
55221   }
55222   {
55223     try {
55224       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55225     } catch (std::out_of_range& e) {
55226       {
55227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55228       };
55229     } catch (std::exception& e) {
55230       {
55231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55232       };
55233     } catch (Dali::DaliException e) {
55234       {
55235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55236       };
55237     } catch (...) {
55238       {
55239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55240       };
55241     }
55242   }
55243
55244 }
55245
55246
55247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55248   void * jresult ;
55249   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55250
55251   {
55252     try {
55253       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55254     } catch (std::out_of_range& e) {
55255       {
55256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55257       };
55258     } catch (std::exception& e) {
55259       {
55260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55261       };
55262     } catch (Dali::DaliException e) {
55263       {
55264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55265       };
55266     } catch (...) {
55267       {
55268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55269       };
55270     }
55271   }
55272
55273   jresult = (void *)result;
55274   return jresult;
55275 }
55276
55277
55278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55279   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55280
55281   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55282   {
55283     try {
55284       delete arg1;
55285     } catch (std::out_of_range& e) {
55286       {
55287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55288       };
55289     } catch (std::exception& e) {
55290       {
55291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55292       };
55293     } catch (Dali::DaliException e) {
55294       {
55295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55296       };
55297     } catch (...) {
55298       {
55299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55300       };
55301     }
55302   }
55303
55304 }
55305
55306
55307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55308   unsigned int jresult ;
55309   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55310   bool result;
55311
55312   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55313   {
55314     try {
55315       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);
55316     } catch (std::out_of_range& e) {
55317       {
55318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55319       };
55320     } catch (std::exception& e) {
55321       {
55322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55323       };
55324     } catch (Dali::DaliException e) {
55325       {
55326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55327       };
55328     } catch (...) {
55329       {
55330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55331       };
55332     }
55333   }
55334
55335   jresult = result;
55336   return jresult;
55337 }
55338
55339
55340 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55341   unsigned long jresult ;
55342   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55343   std::size_t result;
55344
55345   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55346   {
55347     try {
55348       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);
55349     } catch (std::out_of_range& e) {
55350       {
55351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55352       };
55353     } catch (std::exception& e) {
55354       {
55355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55356       };
55357     } catch (Dali::DaliException e) {
55358       {
55359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55360       };
55361     } catch (...) {
55362       {
55363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55364       };
55365     }
55366   }
55367
55368   jresult = (unsigned long)result;
55369   return jresult;
55370 }
55371
55372
55373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55374   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55375   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55376
55377   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55378   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55379   {
55380     try {
55381       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55382     } catch (std::out_of_range& e) {
55383       {
55384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55385       };
55386     } catch (std::exception& e) {
55387       {
55388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55389       };
55390     } catch (Dali::DaliException e) {
55391       {
55392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55393       };
55394     } catch (...) {
55395       {
55396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55397       };
55398     }
55399   }
55400
55401 }
55402
55403
55404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55405   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55406   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55407
55408   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55409   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55410   {
55411     try {
55412       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55413     } catch (std::out_of_range& e) {
55414       {
55415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55416       };
55417     } catch (std::exception& e) {
55418       {
55419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55420       };
55421     } catch (Dali::DaliException e) {
55422       {
55423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55424       };
55425     } catch (...) {
55426       {
55427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55428       };
55429     }
55430   }
55431
55432 }
55433
55434
55435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55436   unsigned int jresult ;
55437   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55438   Dali::Actor arg2 ;
55439   Dali::TouchData *arg3 = 0 ;
55440   Dali::Actor *argp2 ;
55441   bool result;
55442
55443   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55444   argp2 = (Dali::Actor *)jarg2;
55445   if (!argp2) {
55446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55447     return 0;
55448   }
55449   arg2 = *argp2;
55450   arg3 = (Dali::TouchData *)jarg3;
55451   if (!arg3) {
55452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55453     return 0;
55454   }
55455   {
55456     try {
55457       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55458     } catch (std::out_of_range& e) {
55459       {
55460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55461       };
55462     } catch (std::exception& e) {
55463       {
55464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55465       };
55466     } catch (Dali::DaliException e) {
55467       {
55468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55469       };
55470     } catch (...) {
55471       {
55472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55473       };
55474     }
55475   }
55476
55477   jresult = result;
55478   return jresult;
55479 }
55480
55481
55482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55483   void * jresult ;
55484   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55485
55486   {
55487     try {
55488       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55489     } catch (std::out_of_range& e) {
55490       {
55491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55492       };
55493     } catch (std::exception& e) {
55494       {
55495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55496       };
55497     } catch (Dali::DaliException e) {
55498       {
55499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55500       };
55501     } catch (...) {
55502       {
55503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55504       };
55505     }
55506   }
55507
55508   jresult = (void *)result;
55509   return jresult;
55510 }
55511
55512
55513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55514   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55515
55516   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55517   {
55518     try {
55519       delete arg1;
55520     } catch (std::out_of_range& e) {
55521       {
55522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55523       };
55524     } catch (std::exception& e) {
55525       {
55526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55527       };
55528     } catch (Dali::DaliException e) {
55529       {
55530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55531       };
55532     } catch (...) {
55533       {
55534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55535       };
55536     }
55537   }
55538
55539 }
55540
55541
55542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55543   unsigned int jresult ;
55544   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55545   bool result;
55546
55547   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55548   {
55549     try {
55550       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);
55551     } catch (std::out_of_range& e) {
55552       {
55553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55554       };
55555     } catch (std::exception& e) {
55556       {
55557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55558       };
55559     } catch (Dali::DaliException e) {
55560       {
55561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55562       };
55563     } catch (...) {
55564       {
55565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55566       };
55567     }
55568   }
55569
55570   jresult = result;
55571   return jresult;
55572 }
55573
55574
55575 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55576   unsigned long jresult ;
55577   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55578   std::size_t result;
55579
55580   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55581   {
55582     try {
55583       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);
55584     } catch (std::out_of_range& e) {
55585       {
55586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55587       };
55588     } catch (std::exception& e) {
55589       {
55590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55591       };
55592     } catch (Dali::DaliException e) {
55593       {
55594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55595       };
55596     } catch (...) {
55597       {
55598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55599       };
55600     }
55601   }
55602
55603   jresult = (unsigned long)result;
55604   return jresult;
55605 }
55606
55607
55608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55609   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55610   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55611
55612   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55613   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55614   {
55615     try {
55616       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55617     } catch (std::out_of_range& e) {
55618       {
55619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55620       };
55621     } catch (std::exception& e) {
55622       {
55623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55624       };
55625     } catch (Dali::DaliException e) {
55626       {
55627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55628       };
55629     } catch (...) {
55630       {
55631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55632       };
55633     }
55634   }
55635
55636 }
55637
55638
55639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55640   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55641   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55642
55643   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55644   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55645   {
55646     try {
55647       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55648     } catch (std::out_of_range& e) {
55649       {
55650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55651       };
55652     } catch (std::exception& e) {
55653       {
55654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55655       };
55656     } catch (Dali::DaliException e) {
55657       {
55658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55659       };
55660     } catch (...) {
55661       {
55662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55663       };
55664     }
55665   }
55666
55667 }
55668
55669
55670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55671   unsigned int jresult ;
55672   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55673   Dali::Actor arg2 ;
55674   Dali::HoverEvent *arg3 = 0 ;
55675   Dali::Actor *argp2 ;
55676   bool result;
55677
55678   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55679   argp2 = (Dali::Actor *)jarg2;
55680   if (!argp2) {
55681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55682     return 0;
55683   }
55684   arg2 = *argp2;
55685   arg3 = (Dali::HoverEvent *)jarg3;
55686   if (!arg3) {
55687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55688     return 0;
55689   }
55690   {
55691     try {
55692       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55693     } catch (std::out_of_range& e) {
55694       {
55695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55696       };
55697     } catch (std::exception& e) {
55698       {
55699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55700       };
55701     } catch (Dali::DaliException e) {
55702       {
55703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55704       };
55705     } catch (...) {
55706       {
55707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55708       };
55709     }
55710   }
55711
55712   jresult = result;
55713   return jresult;
55714 }
55715
55716
55717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55718   void * jresult ;
55719   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55720
55721   {
55722     try {
55723       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55724     } catch (std::out_of_range& e) {
55725       {
55726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55727       };
55728     } catch (std::exception& e) {
55729       {
55730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55731       };
55732     } catch (Dali::DaliException e) {
55733       {
55734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55735       };
55736     } catch (...) {
55737       {
55738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55739       };
55740     }
55741   }
55742
55743   jresult = (void *)result;
55744   return jresult;
55745 }
55746
55747
55748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55749   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55750
55751   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55752   {
55753     try {
55754       delete arg1;
55755     } catch (std::out_of_range& e) {
55756       {
55757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55758       };
55759     } catch (std::exception& e) {
55760       {
55761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55762       };
55763     } catch (Dali::DaliException e) {
55764       {
55765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55766       };
55767     } catch (...) {
55768       {
55769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55770       };
55771     }
55772   }
55773
55774 }
55775
55776
55777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55778   unsigned int jresult ;
55779   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55780   bool result;
55781
55782   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55783   {
55784     try {
55785       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);
55786     } catch (std::out_of_range& e) {
55787       {
55788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55789       };
55790     } catch (std::exception& e) {
55791       {
55792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55793       };
55794     } catch (Dali::DaliException e) {
55795       {
55796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55797       };
55798     } catch (...) {
55799       {
55800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55801       };
55802     }
55803   }
55804
55805   jresult = result;
55806   return jresult;
55807 }
55808
55809
55810 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55811   unsigned long jresult ;
55812   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55813   std::size_t result;
55814
55815   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55816   {
55817     try {
55818       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);
55819     } catch (std::out_of_range& e) {
55820       {
55821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55822       };
55823     } catch (std::exception& e) {
55824       {
55825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55826       };
55827     } catch (Dali::DaliException e) {
55828       {
55829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55830       };
55831     } catch (...) {
55832       {
55833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55834       };
55835     }
55836   }
55837
55838   jresult = (unsigned long)result;
55839   return jresult;
55840 }
55841
55842
55843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55844   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55845   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55846
55847   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55848   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55849   {
55850     try {
55851       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55852     } catch (std::out_of_range& e) {
55853       {
55854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55855       };
55856     } catch (std::exception& e) {
55857       {
55858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55859       };
55860     } catch (Dali::DaliException e) {
55861       {
55862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55863       };
55864     } catch (...) {
55865       {
55866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55867       };
55868     }
55869   }
55870
55871 }
55872
55873
55874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55875   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55876   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55877
55878   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55879   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55880   {
55881     try {
55882       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55883     } catch (std::out_of_range& e) {
55884       {
55885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55886       };
55887     } catch (std::exception& e) {
55888       {
55889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55890       };
55891     } catch (Dali::DaliException e) {
55892       {
55893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55894       };
55895     } catch (...) {
55896       {
55897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55898       };
55899     }
55900   }
55901
55902 }
55903
55904
55905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55906   unsigned int jresult ;
55907   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55908   Dali::Actor arg2 ;
55909   Dali::WheelEvent *arg3 = 0 ;
55910   Dali::Actor *argp2 ;
55911   bool result;
55912
55913   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55914   argp2 = (Dali::Actor *)jarg2;
55915   if (!argp2) {
55916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55917     return 0;
55918   }
55919   arg2 = *argp2;
55920   arg3 = (Dali::WheelEvent *)jarg3;
55921   if (!arg3) {
55922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55923     return 0;
55924   }
55925   {
55926     try {
55927       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55928     } catch (std::out_of_range& e) {
55929       {
55930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55931       };
55932     } catch (std::exception& e) {
55933       {
55934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55935       };
55936     } catch (Dali::DaliException e) {
55937       {
55938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55939       };
55940     } catch (...) {
55941       {
55942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55943       };
55944     }
55945   }
55946
55947   jresult = result;
55948   return jresult;
55949 }
55950
55951
55952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55953   void * jresult ;
55954   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55955
55956   {
55957     try {
55958       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55959     } catch (std::out_of_range& e) {
55960       {
55961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55962       };
55963     } catch (std::exception& e) {
55964       {
55965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55966       };
55967     } catch (Dali::DaliException e) {
55968       {
55969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55970       };
55971     } catch (...) {
55972       {
55973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55974       };
55975     }
55976   }
55977
55978   jresult = (void *)result;
55979   return jresult;
55980 }
55981
55982
55983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55984   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55985
55986   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55987   {
55988     try {
55989       delete arg1;
55990     } catch (std::out_of_range& e) {
55991       {
55992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55993       };
55994     } catch (std::exception& e) {
55995       {
55996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55997       };
55998     } catch (Dali::DaliException e) {
55999       {
56000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56001       };
56002     } catch (...) {
56003       {
56004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56005       };
56006     }
56007   }
56008
56009 }
56010
56011
56012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56013   unsigned int jresult ;
56014   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56015   bool result;
56016
56017   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56018   {
56019     try {
56020       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56021     } catch (std::out_of_range& e) {
56022       {
56023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56024       };
56025     } catch (std::exception& e) {
56026       {
56027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56028       };
56029     } catch (Dali::DaliException e) {
56030       {
56031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56032       };
56033     } catch (...) {
56034       {
56035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56036       };
56037     }
56038   }
56039
56040   jresult = result;
56041   return jresult;
56042 }
56043
56044
56045 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56046   unsigned long jresult ;
56047   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56048   std::size_t result;
56049
56050   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56051   {
56052     try {
56053       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56054     } catch (std::out_of_range& e) {
56055       {
56056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56057       };
56058     } catch (std::exception& e) {
56059       {
56060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56061       };
56062     } catch (Dali::DaliException e) {
56063       {
56064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56065       };
56066     } catch (...) {
56067       {
56068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56069       };
56070     }
56071   }
56072
56073   jresult = (unsigned long)result;
56074   return jresult;
56075 }
56076
56077
56078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56079   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56080   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56081
56082   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56083   arg2 = (void (*)(Dali::Actor))jarg2;
56084   {
56085     try {
56086       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56087     } catch (std::out_of_range& e) {
56088       {
56089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56090       };
56091     } catch (std::exception& e) {
56092       {
56093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56094       };
56095     } catch (Dali::DaliException e) {
56096       {
56097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56098       };
56099     } catch (...) {
56100       {
56101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56102       };
56103     }
56104   }
56105
56106 }
56107
56108
56109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56110   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56111   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56112
56113   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56114   arg2 = (void (*)(Dali::Actor))jarg2;
56115   {
56116     try {
56117       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56118     } catch (std::out_of_range& e) {
56119       {
56120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56121       };
56122     } catch (std::exception& e) {
56123       {
56124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56125       };
56126     } catch (Dali::DaliException e) {
56127       {
56128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56129       };
56130     } catch (...) {
56131       {
56132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56133       };
56134     }
56135   }
56136
56137 }
56138
56139
56140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56141   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56142   Dali::Actor arg2 ;
56143   Dali::Actor *argp2 ;
56144
56145   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56146   argp2 = (Dali::Actor *)jarg2;
56147   if (!argp2) {
56148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56149     return ;
56150   }
56151   arg2 = *argp2;
56152   {
56153     try {
56154       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56155     } catch (std::out_of_range& e) {
56156       {
56157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56158       };
56159     } catch (std::exception& e) {
56160       {
56161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56162       };
56163     } catch (Dali::DaliException e) {
56164       {
56165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56166       };
56167     } catch (...) {
56168       {
56169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56170       };
56171     }
56172   }
56173
56174 }
56175
56176
56177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56178   void * jresult ;
56179   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56180
56181   {
56182     try {
56183       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56184     } catch (std::out_of_range& e) {
56185       {
56186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56187       };
56188     } catch (std::exception& e) {
56189       {
56190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56191       };
56192     } catch (Dali::DaliException e) {
56193       {
56194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56195       };
56196     } catch (...) {
56197       {
56198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56199       };
56200     }
56201   }
56202
56203   jresult = (void *)result;
56204   return jresult;
56205 }
56206
56207
56208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56209   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56210
56211   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56212   {
56213     try {
56214       delete arg1;
56215     } catch (std::out_of_range& e) {
56216       {
56217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56218       };
56219     } catch (std::exception& e) {
56220       {
56221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56222       };
56223     } catch (Dali::DaliException e) {
56224       {
56225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56226       };
56227     } catch (...) {
56228       {
56229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56230       };
56231     }
56232   }
56233
56234 }
56235
56236
56237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56238   unsigned int jresult ;
56239   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56240   bool result;
56241
56242   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56243   {
56244     try {
56245       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56246     } catch (std::out_of_range& e) {
56247       {
56248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56249       };
56250     } catch (std::exception& e) {
56251       {
56252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56253       };
56254     } catch (Dali::DaliException e) {
56255       {
56256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56257       };
56258     } catch (...) {
56259       {
56260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56261       };
56262     }
56263   }
56264
56265   jresult = result;
56266   return jresult;
56267 }
56268
56269
56270 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56271   unsigned long jresult ;
56272   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56273   std::size_t result;
56274
56275   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56276   {
56277     try {
56278       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56279     } catch (std::out_of_range& e) {
56280       {
56281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56282       };
56283     } catch (std::exception& e) {
56284       {
56285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56286       };
56287     } catch (Dali::DaliException e) {
56288       {
56289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56290       };
56291     } catch (...) {
56292       {
56293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56294       };
56295     }
56296   }
56297
56298   jresult = (unsigned long)result;
56299   return jresult;
56300 }
56301
56302
56303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56304   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56305   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56306
56307   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56308   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56309   {
56310     try {
56311       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56312     } catch (std::out_of_range& e) {
56313       {
56314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56315       };
56316     } catch (std::exception& e) {
56317       {
56318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56319       };
56320     } catch (Dali::DaliException e) {
56321       {
56322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56323       };
56324     } catch (...) {
56325       {
56326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56327       };
56328     }
56329   }
56330
56331 }
56332
56333
56334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56335   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56336   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56337
56338   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56339   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56340   {
56341     try {
56342       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56343     } catch (std::out_of_range& e) {
56344       {
56345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56346       };
56347     } catch (std::exception& e) {
56348       {
56349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56350       };
56351     } catch (Dali::DaliException e) {
56352       {
56353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56354       };
56355     } catch (...) {
56356       {
56357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56358       };
56359     }
56360   }
56361
56362 }
56363
56364
56365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56366   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56367   Dali::KeyEvent *arg2 = 0 ;
56368
56369   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56370   arg2 = (Dali::KeyEvent *)jarg2;
56371   if (!arg2) {
56372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56373     return ;
56374   }
56375   {
56376     try {
56377       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56378     } catch (std::out_of_range& e) {
56379       {
56380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56381       };
56382     } catch (std::exception& e) {
56383       {
56384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56385       };
56386     } catch (Dali::DaliException e) {
56387       {
56388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56389       };
56390     } catch (...) {
56391       {
56392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56393       };
56394     }
56395   }
56396
56397 }
56398
56399
56400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56401   void * jresult ;
56402   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56403
56404   {
56405     try {
56406       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56407     } catch (std::out_of_range& e) {
56408       {
56409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56410       };
56411     } catch (std::exception& e) {
56412       {
56413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56414       };
56415     } catch (Dali::DaliException e) {
56416       {
56417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56418       };
56419     } catch (...) {
56420       {
56421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56422       };
56423     }
56424   }
56425
56426   jresult = (void *)result;
56427   return jresult;
56428 }
56429
56430
56431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56432   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56433
56434   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56435   {
56436     try {
56437       delete arg1;
56438     } catch (std::out_of_range& e) {
56439       {
56440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56441       };
56442     } catch (std::exception& e) {
56443       {
56444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56445       };
56446     } catch (Dali::DaliException e) {
56447       {
56448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56449       };
56450     } catch (...) {
56451       {
56452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56453       };
56454     }
56455   }
56456
56457 }
56458
56459
56460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56461   unsigned int jresult ;
56462   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56463   bool result;
56464
56465   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56466   {
56467     try {
56468       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56469     } catch (std::out_of_range& e) {
56470       {
56471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56472       };
56473     } catch (std::exception& e) {
56474       {
56475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56476       };
56477     } catch (Dali::DaliException e) {
56478       {
56479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56480       };
56481     } catch (...) {
56482       {
56483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56484       };
56485     }
56486   }
56487
56488   jresult = result;
56489   return jresult;
56490 }
56491
56492
56493 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56494   unsigned long jresult ;
56495   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56496   std::size_t result;
56497
56498   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56499   {
56500     try {
56501       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56502     } catch (std::out_of_range& e) {
56503       {
56504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56505       };
56506     } catch (std::exception& e) {
56507       {
56508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56509       };
56510     } catch (Dali::DaliException e) {
56511       {
56512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56513       };
56514     } catch (...) {
56515       {
56516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56517       };
56518     }
56519   }
56520
56521   jresult = (unsigned long)result;
56522   return jresult;
56523 }
56524
56525
56526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56527   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56528   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56529
56530   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56531   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56532   {
56533     try {
56534       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56535     } catch (std::out_of_range& e) {
56536       {
56537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56538       };
56539     } catch (std::exception& e) {
56540       {
56541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56542       };
56543     } catch (Dali::DaliException e) {
56544       {
56545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56546       };
56547     } catch (...) {
56548       {
56549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56550       };
56551     }
56552   }
56553
56554 }
56555
56556
56557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56558   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56559   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56560
56561   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56562   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56563   {
56564     try {
56565       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56566     } catch (std::out_of_range& e) {
56567       {
56568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56569       };
56570     } catch (std::exception& e) {
56571       {
56572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56573       };
56574     } catch (Dali::DaliException e) {
56575       {
56576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56577       };
56578     } catch (...) {
56579       {
56580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56581       };
56582     }
56583   }
56584
56585 }
56586
56587
56588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56589   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56590   Dali::TouchData *arg2 = 0 ;
56591
56592   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56593   arg2 = (Dali::TouchData *)jarg2;
56594   if (!arg2) {
56595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56596     return ;
56597   }
56598   {
56599     try {
56600       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56601     } catch (std::out_of_range& e) {
56602       {
56603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56604       };
56605     } catch (std::exception& e) {
56606       {
56607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56608       };
56609     } catch (Dali::DaliException e) {
56610       {
56611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56612       };
56613     } catch (...) {
56614       {
56615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56616       };
56617     }
56618   }
56619
56620 }
56621
56622
56623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56624   void * jresult ;
56625   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56626
56627   {
56628     try {
56629       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56630     } catch (std::out_of_range& e) {
56631       {
56632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56633       };
56634     } catch (std::exception& e) {
56635       {
56636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56637       };
56638     } catch (Dali::DaliException e) {
56639       {
56640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56641       };
56642     } catch (...) {
56643       {
56644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56645       };
56646     }
56647   }
56648
56649   jresult = (void *)result;
56650   return jresult;
56651 }
56652
56653
56654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56655   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56656
56657   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56658   {
56659     try {
56660       delete arg1;
56661     } catch (std::out_of_range& e) {
56662       {
56663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56664       };
56665     } catch (std::exception& e) {
56666       {
56667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56668       };
56669     } catch (Dali::DaliException e) {
56670       {
56671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56672       };
56673     } catch (...) {
56674       {
56675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56676       };
56677     }
56678   }
56679
56680 }
56681
56682
56683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56684   unsigned int jresult ;
56685   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56686   bool result;
56687
56688   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56689   {
56690     try {
56691       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56692     } catch (std::out_of_range& e) {
56693       {
56694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56695       };
56696     } catch (std::exception& e) {
56697       {
56698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56699       };
56700     } catch (Dali::DaliException e) {
56701       {
56702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56703       };
56704     } catch (...) {
56705       {
56706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56707       };
56708     }
56709   }
56710
56711   jresult = result;
56712   return jresult;
56713 }
56714
56715
56716 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56717   unsigned long jresult ;
56718   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56719   std::size_t result;
56720
56721   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56722   {
56723     try {
56724       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56725     } catch (std::out_of_range& e) {
56726       {
56727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56728       };
56729     } catch (std::exception& e) {
56730       {
56731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56732       };
56733     } catch (Dali::DaliException e) {
56734       {
56735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56736       };
56737     } catch (...) {
56738       {
56739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56740       };
56741     }
56742   }
56743
56744   jresult = (unsigned long)result;
56745   return jresult;
56746 }
56747
56748
56749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56750   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56751   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56752
56753   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56754   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56755   {
56756     try {
56757       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56758     } catch (std::out_of_range& e) {
56759       {
56760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56761       };
56762     } catch (std::exception& e) {
56763       {
56764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56765       };
56766     } catch (Dali::DaliException e) {
56767       {
56768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56769       };
56770     } catch (...) {
56771       {
56772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56773       };
56774     }
56775   }
56776
56777 }
56778
56779
56780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56781   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56782   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56783
56784   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56785   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56786   {
56787     try {
56788       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56789     } catch (std::out_of_range& e) {
56790       {
56791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56792       };
56793     } catch (std::exception& e) {
56794       {
56795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56796       };
56797     } catch (Dali::DaliException e) {
56798       {
56799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56800       };
56801     } catch (...) {
56802       {
56803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56804       };
56805     }
56806   }
56807
56808 }
56809
56810
56811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56812   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56813   Dali::WheelEvent *arg2 = 0 ;
56814
56815   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56816   arg2 = (Dali::WheelEvent *)jarg2;
56817   if (!arg2) {
56818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56819     return ;
56820   }
56821   {
56822     try {
56823       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56824     } catch (std::out_of_range& e) {
56825       {
56826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56827       };
56828     } catch (std::exception& e) {
56829       {
56830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56831       };
56832     } catch (Dali::DaliException e) {
56833       {
56834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56835       };
56836     } catch (...) {
56837       {
56838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56839       };
56840     }
56841   }
56842
56843 }
56844
56845
56846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56847   void * jresult ;
56848   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56849
56850   {
56851     try {
56852       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56853     } catch (std::out_of_range& e) {
56854       {
56855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56856       };
56857     } catch (std::exception& e) {
56858       {
56859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56860       };
56861     } catch (Dali::DaliException e) {
56862       {
56863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56864       };
56865     } catch (...) {
56866       {
56867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56868       };
56869     }
56870   }
56871
56872   jresult = (void *)result;
56873   return jresult;
56874 }
56875
56876
56877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56878   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56879
56880   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56881   {
56882     try {
56883       delete arg1;
56884     } catch (std::out_of_range& e) {
56885       {
56886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56887       };
56888     } catch (std::exception& e) {
56889       {
56890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56891       };
56892     } catch (Dali::DaliException e) {
56893       {
56894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56895       };
56896     } catch (...) {
56897       {
56898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56899       };
56900     }
56901   }
56902
56903 }
56904
56905
56906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56907   void * jresult ;
56908   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56909
56910   {
56911     try {
56912       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56913     } catch (std::out_of_range& e) {
56914       {
56915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56916       };
56917     } catch (std::exception& e) {
56918       {
56919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56920       };
56921     } catch (Dali::DaliException e) {
56922       {
56923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56924       };
56925     } catch (...) {
56926       {
56927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56928       };
56929     }
56930   }
56931
56932   jresult = (void *)result;
56933   return jresult;
56934 }
56935
56936
56937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56938   void * jresult ;
56939   Dali::Radian arg1 ;
56940   Dali::Radian arg2 ;
56941   Dali::Radian *argp1 ;
56942   Dali::Radian *argp2 ;
56943   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56944
56945   argp1 = (Dali::Radian *)jarg1;
56946   if (!argp1) {
56947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56948     return 0;
56949   }
56950   arg1 = *argp1;
56951   argp2 = (Dali::Radian *)jarg2;
56952   if (!argp2) {
56953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56954     return 0;
56955   }
56956   arg2 = *argp2;
56957   {
56958     try {
56959       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56960     } catch (std::out_of_range& e) {
56961       {
56962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56963       };
56964     } catch (std::exception& e) {
56965       {
56966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56967       };
56968     } catch (Dali::DaliException e) {
56969       {
56970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56971       };
56972     } catch (...) {
56973       {
56974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56975       };
56976     }
56977   }
56978
56979   jresult = (void *)result;
56980   return jresult;
56981 }
56982
56983
56984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56985   void * jresult ;
56986   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56987   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56988
56989   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56990   if (!arg1) {
56991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56992     return 0;
56993   }
56994   {
56995     try {
56996       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56997     } catch (std::out_of_range& e) {
56998       {
56999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57000       };
57001     } catch (std::exception& e) {
57002       {
57003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57004       };
57005     } catch (Dali::DaliException e) {
57006       {
57007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57008       };
57009     } catch (...) {
57010       {
57011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57012       };
57013     }
57014   }
57015
57016   jresult = (void *)result;
57017   return jresult;
57018 }
57019
57020
57021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57022   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57023   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57024
57025   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57026   arg2 = (Dali::Radian *)jarg2;
57027   if (arg1) (arg1)->first = *arg2;
57028 }
57029
57030
57031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57032   void * jresult ;
57033   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57034   Dali::Radian *result = 0 ;
57035
57036   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57037   result = (Dali::Radian *)& ((arg1)->first);
57038   jresult = (void *)result;
57039   return jresult;
57040 }
57041
57042
57043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57044   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57045   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57046
57047   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57048   arg2 = (Dali::Radian *)jarg2;
57049   if (arg1) (arg1)->second = *arg2;
57050 }
57051
57052
57053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57054   void * jresult ;
57055   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57056   Dali::Radian *result = 0 ;
57057
57058   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57059   result = (Dali::Radian *)& ((arg1)->second);
57060   jresult = (void *)result;
57061   return jresult;
57062 }
57063
57064
57065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57066   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57067
57068   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57069   {
57070     try {
57071       delete arg1;
57072     } catch (std::out_of_range& e) {
57073       {
57074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57075       };
57076     } catch (std::exception& e) {
57077       {
57078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57079       };
57080     } catch (Dali::DaliException e) {
57081       {
57082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57083       };
57084     } catch (...) {
57085       {
57086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57087       };
57088     }
57089   }
57090
57091 }
57092
57093
57094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57095   unsigned int jresult ;
57096   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57097   bool result;
57098
57099   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57100   {
57101     try {
57102       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);
57103     } catch (std::out_of_range& e) {
57104       {
57105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57106       };
57107     } catch (std::exception& e) {
57108       {
57109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57110       };
57111     } catch (Dali::DaliException e) {
57112       {
57113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57114       };
57115     } catch (...) {
57116       {
57117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57118       };
57119     }
57120   }
57121
57122   jresult = result;
57123   return jresult;
57124 }
57125
57126
57127 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57128   unsigned long jresult ;
57129   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57130   std::size_t result;
57131
57132   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57133   {
57134     try {
57135       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);
57136     } catch (std::out_of_range& e) {
57137       {
57138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57139       };
57140     } catch (std::exception& e) {
57141       {
57142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57143       };
57144     } catch (Dali::DaliException e) {
57145       {
57146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57147       };
57148     } catch (...) {
57149       {
57150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57151       };
57152     }
57153   }
57154
57155   jresult = (unsigned long)result;
57156   return jresult;
57157 }
57158
57159
57160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57161   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57162   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57163
57164   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57165   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57166   {
57167     try {
57168       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57169     } catch (std::out_of_range& e) {
57170       {
57171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57172       };
57173     } catch (std::exception& e) {
57174       {
57175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57176       };
57177     } catch (Dali::DaliException e) {
57178       {
57179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57180       };
57181     } catch (...) {
57182       {
57183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57184       };
57185     }
57186   }
57187
57188 }
57189
57190
57191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57192   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57193   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57194
57195   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57196   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57197   {
57198     try {
57199       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57200     } catch (std::out_of_range& e) {
57201       {
57202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57203       };
57204     } catch (std::exception& e) {
57205       {
57206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57207       };
57208     } catch (Dali::DaliException e) {
57209       {
57210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57211       };
57212     } catch (...) {
57213       {
57214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57215       };
57216     }
57217   }
57218
57219 }
57220
57221
57222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57223   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57224   Dali::Actor arg2 ;
57225   Dali::PanGesture *arg3 = 0 ;
57226   Dali::Actor *argp2 ;
57227
57228   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57229   argp2 = (Dali::Actor *)jarg2;
57230   if (!argp2) {
57231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57232     return ;
57233   }
57234   arg2 = *argp2;
57235   arg3 = (Dali::PanGesture *)jarg3;
57236   if (!arg3) {
57237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57238     return ;
57239   }
57240   {
57241     try {
57242       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57243     } catch (std::out_of_range& e) {
57244       {
57245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57246       };
57247     } catch (std::exception& e) {
57248       {
57249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57250       };
57251     } catch (Dali::DaliException e) {
57252       {
57253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57254       };
57255     } catch (...) {
57256       {
57257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57258       };
57259     }
57260   }
57261
57262 }
57263
57264
57265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57266   void * jresult ;
57267   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57268
57269   {
57270     try {
57271       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57272     } catch (std::out_of_range& e) {
57273       {
57274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57275       };
57276     } catch (std::exception& e) {
57277       {
57278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57279       };
57280     } catch (Dali::DaliException e) {
57281       {
57282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57283       };
57284     } catch (...) {
57285       {
57286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57287       };
57288     }
57289   }
57290
57291   jresult = (void *)result;
57292   return jresult;
57293 }
57294
57295
57296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57297   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57298
57299   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57300   {
57301     try {
57302       delete arg1;
57303     } catch (std::out_of_range& e) {
57304       {
57305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57306       };
57307     } catch (std::exception& e) {
57308       {
57309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57310       };
57311     } catch (Dali::DaliException e) {
57312       {
57313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57314       };
57315     } catch (...) {
57316       {
57317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57318       };
57319     }
57320   }
57321
57322 }
57323
57324
57325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57326   unsigned int jresult ;
57327   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57328   bool result;
57329
57330   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57331   {
57332     try {
57333       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);
57334     } catch (std::out_of_range& e) {
57335       {
57336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57337       };
57338     } catch (std::exception& e) {
57339       {
57340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57341       };
57342     } catch (Dali::DaliException e) {
57343       {
57344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57345       };
57346     } catch (...) {
57347       {
57348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57349       };
57350     }
57351   }
57352
57353   jresult = result;
57354   return jresult;
57355 }
57356
57357
57358 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57359   unsigned long jresult ;
57360   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57361   std::size_t result;
57362
57363   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57364   {
57365     try {
57366       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);
57367     } catch (std::out_of_range& e) {
57368       {
57369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57370       };
57371     } catch (std::exception& e) {
57372       {
57373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57374       };
57375     } catch (Dali::DaliException e) {
57376       {
57377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57378       };
57379     } catch (...) {
57380       {
57381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57382       };
57383     }
57384   }
57385
57386   jresult = (unsigned long)result;
57387   return jresult;
57388 }
57389
57390
57391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57392   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57393   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57394
57395   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57396   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57397   {
57398     try {
57399       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57400     } catch (std::out_of_range& e) {
57401       {
57402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57403       };
57404     } catch (std::exception& e) {
57405       {
57406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57407       };
57408     } catch (Dali::DaliException e) {
57409       {
57410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57411       };
57412     } catch (...) {
57413       {
57414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57415       };
57416     }
57417   }
57418
57419 }
57420
57421
57422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57423   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57424   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57425
57426   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57427   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57428   {
57429     try {
57430       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57431     } catch (std::out_of_range& e) {
57432       {
57433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57434       };
57435     } catch (std::exception& e) {
57436       {
57437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57438       };
57439     } catch (Dali::DaliException e) {
57440       {
57441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57442       };
57443     } catch (...) {
57444       {
57445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57446       };
57447     }
57448   }
57449
57450 }
57451
57452
57453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57454   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57455   Dali::Actor arg2 ;
57456   Dali::PinchGesture *arg3 = 0 ;
57457   Dali::Actor *argp2 ;
57458
57459   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57460   argp2 = (Dali::Actor *)jarg2;
57461   if (!argp2) {
57462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57463     return ;
57464   }
57465   arg2 = *argp2;
57466   arg3 = (Dali::PinchGesture *)jarg3;
57467   if (!arg3) {
57468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57469     return ;
57470   }
57471   {
57472     try {
57473       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57474     } catch (std::out_of_range& e) {
57475       {
57476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57477       };
57478     } catch (std::exception& e) {
57479       {
57480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57481       };
57482     } catch (Dali::DaliException e) {
57483       {
57484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57485       };
57486     } catch (...) {
57487       {
57488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57489       };
57490     }
57491   }
57492
57493 }
57494
57495
57496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57497   void * jresult ;
57498   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57499
57500   {
57501     try {
57502       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57503     } catch (std::out_of_range& e) {
57504       {
57505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57506       };
57507     } catch (std::exception& e) {
57508       {
57509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57510       };
57511     } catch (Dali::DaliException e) {
57512       {
57513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57514       };
57515     } catch (...) {
57516       {
57517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57518       };
57519     }
57520   }
57521
57522   jresult = (void *)result;
57523   return jresult;
57524 }
57525
57526
57527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57528   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57529
57530   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57531   {
57532     try {
57533       delete arg1;
57534     } catch (std::out_of_range& e) {
57535       {
57536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57537       };
57538     } catch (std::exception& e) {
57539       {
57540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57541       };
57542     } catch (Dali::DaliException e) {
57543       {
57544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57545       };
57546     } catch (...) {
57547       {
57548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57549       };
57550     }
57551   }
57552
57553 }
57554
57555
57556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57557   unsigned int jresult ;
57558   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57559   bool result;
57560
57561   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57562   {
57563     try {
57564       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);
57565     } catch (std::out_of_range& e) {
57566       {
57567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57568       };
57569     } catch (std::exception& e) {
57570       {
57571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57572       };
57573     } catch (Dali::DaliException e) {
57574       {
57575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57576       };
57577     } catch (...) {
57578       {
57579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57580       };
57581     }
57582   }
57583
57584   jresult = result;
57585   return jresult;
57586 }
57587
57588
57589 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57590   unsigned long jresult ;
57591   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57592   std::size_t result;
57593
57594   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57595   {
57596     try {
57597       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);
57598     } catch (std::out_of_range& e) {
57599       {
57600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57601       };
57602     } catch (std::exception& e) {
57603       {
57604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57605       };
57606     } catch (Dali::DaliException e) {
57607       {
57608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57609       };
57610     } catch (...) {
57611       {
57612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57613       };
57614     }
57615   }
57616
57617   jresult = (unsigned long)result;
57618   return jresult;
57619 }
57620
57621
57622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57623   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57624   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57625
57626   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57627   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57628   {
57629     try {
57630       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57631     } catch (std::out_of_range& e) {
57632       {
57633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57634       };
57635     } catch (std::exception& e) {
57636       {
57637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57638       };
57639     } catch (Dali::DaliException e) {
57640       {
57641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57642       };
57643     } catch (...) {
57644       {
57645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57646       };
57647     }
57648   }
57649
57650 }
57651
57652
57653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57654   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57655   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57656
57657   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57658   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57659   {
57660     try {
57661       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57662     } catch (std::out_of_range& e) {
57663       {
57664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57665       };
57666     } catch (std::exception& e) {
57667       {
57668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57669       };
57670     } catch (Dali::DaliException e) {
57671       {
57672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57673       };
57674     } catch (...) {
57675       {
57676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57677       };
57678     }
57679   }
57680
57681 }
57682
57683
57684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57685   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57686   Dali::Actor arg2 ;
57687   Dali::TapGesture *arg3 = 0 ;
57688   Dali::Actor *argp2 ;
57689
57690   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57691   argp2 = (Dali::Actor *)jarg2;
57692   if (!argp2) {
57693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57694     return ;
57695   }
57696   arg2 = *argp2;
57697   arg3 = (Dali::TapGesture *)jarg3;
57698   if (!arg3) {
57699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57700     return ;
57701   }
57702   {
57703     try {
57704       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57705     } catch (std::out_of_range& e) {
57706       {
57707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57708       };
57709     } catch (std::exception& e) {
57710       {
57711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57712       };
57713     } catch (Dali::DaliException e) {
57714       {
57715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57716       };
57717     } catch (...) {
57718       {
57719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57720       };
57721     }
57722   }
57723
57724 }
57725
57726
57727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57728   void * jresult ;
57729   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57730
57731   {
57732     try {
57733       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57734     } catch (std::out_of_range& e) {
57735       {
57736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57737       };
57738     } catch (std::exception& e) {
57739       {
57740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57741       };
57742     } catch (Dali::DaliException e) {
57743       {
57744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57745       };
57746     } catch (...) {
57747       {
57748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57749       };
57750     }
57751   }
57752
57753   jresult = (void *)result;
57754   return jresult;
57755 }
57756
57757
57758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57759   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57760
57761   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57762   {
57763     try {
57764       delete arg1;
57765     } catch (std::out_of_range& e) {
57766       {
57767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57768       };
57769     } catch (std::exception& e) {
57770       {
57771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57772       };
57773     } catch (Dali::DaliException e) {
57774       {
57775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57776       };
57777     } catch (...) {
57778       {
57779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57780       };
57781     }
57782   }
57783
57784 }
57785
57786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57787   unsigned int jresult ;
57788   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57789   bool result;
57790
57791   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57792   {
57793     try {
57794       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57795     } catch (std::out_of_range& e) {
57796       {
57797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57798       };
57799     } catch (std::exception& e) {
57800       {
57801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57802       };
57803     } catch (Dali::DaliException e) {
57804       {
57805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57806       };
57807     } catch (...) {
57808       {
57809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57810       };
57811     }
57812   }
57813
57814   jresult = result;
57815   return jresult;
57816 }
57817
57818
57819 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57820   unsigned long jresult ;
57821   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57822   std::size_t result;
57823
57824   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57825   {
57826     try {
57827       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57828     } catch (std::out_of_range& e) {
57829       {
57830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57831       };
57832     } catch (std::exception& e) {
57833       {
57834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57835       };
57836     } catch (Dali::DaliException e) {
57837       {
57838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57839       };
57840     } catch (...) {
57841       {
57842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57843       };
57844     }
57845   }
57846
57847   jresult = (unsigned long)result;
57848   return jresult;
57849 }
57850
57851
57852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57853   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57854   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57855
57856   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57857   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57858   {
57859     try {
57860       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57861     } catch (std::out_of_range& e) {
57862       {
57863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57864       };
57865     } catch (std::exception& e) {
57866       {
57867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57868       };
57869     } catch (Dali::DaliException e) {
57870       {
57871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57872       };
57873     } catch (...) {
57874       {
57875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57876       };
57877     }
57878   }
57879
57880 }
57881
57882
57883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57884   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57885   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57886
57887   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57888   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57889   {
57890     try {
57891       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57892     } catch (std::out_of_range& e) {
57893       {
57894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57895       };
57896     } catch (std::exception& e) {
57897       {
57898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57899       };
57900     } catch (Dali::DaliException e) {
57901       {
57902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57903       };
57904     } catch (...) {
57905       {
57906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57907       };
57908     }
57909   }
57910
57911 }
57912
57913
57914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57915   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57916   Dali::ResourceImage arg2 ;
57917   Dali::ResourceImage *argp2 ;
57918
57919   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57920   argp2 = (Dali::ResourceImage *)jarg2;
57921   if (!argp2) {
57922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57923     return ;
57924   }
57925   arg2 = *argp2;
57926   {
57927     try {
57928       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57929     } catch (std::out_of_range& e) {
57930       {
57931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57932       };
57933     } catch (std::exception& e) {
57934       {
57935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57936       };
57937     } catch (Dali::DaliException e) {
57938       {
57939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57940       };
57941     } catch (...) {
57942       {
57943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57944       };
57945     }
57946   }
57947
57948 }
57949
57950
57951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57952   void * jresult ;
57953   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57954
57955   {
57956     try {
57957       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57958     } catch (std::out_of_range& e) {
57959       {
57960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57961       };
57962     } catch (std::exception& e) {
57963       {
57964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57965       };
57966     } catch (Dali::DaliException e) {
57967       {
57968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57969       };
57970     } catch (...) {
57971       {
57972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57973       };
57974     }
57975   }
57976
57977   jresult = (void *)result;
57978   return jresult;
57979 }
57980
57981
57982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57983   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57984
57985   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57986   {
57987     try {
57988       delete arg1;
57989     } catch (std::out_of_range& e) {
57990       {
57991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57992       };
57993     } catch (std::exception& e) {
57994       {
57995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57996       };
57997     } catch (Dali::DaliException e) {
57998       {
57999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58000       };
58001     } catch (...) {
58002       {
58003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58004       };
58005     }
58006   }
58007
58008 }
58009
58010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58011   unsigned int jresult ;
58012   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58013   bool result = false;
58014
58015   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58016   {
58017     try {
58018       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);
58019     } catch (std::out_of_range& e) {
58020       {
58021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58022       };
58023     } catch (std::exception& e) {
58024       {
58025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58026       };
58027     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58028   }
58029   jresult = result;
58030   return jresult;
58031 }
58032
58033 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58034   unsigned long jresult ;
58035   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58036   std::size_t result = 0;
58037
58038   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58039   {
58040     try {
58041       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);
58042     } catch (std::out_of_range& e) {
58043       {
58044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58045       };
58046     } catch (std::exception& e) {
58047       {
58048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58049       };
58050     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58051   }
58052   jresult = (unsigned long)result;
58053   return jresult;
58054 }
58055
58056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58057   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58058   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58059
58060   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58061   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58062   {
58063     try {
58064       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58065     } catch (std::out_of_range& e) {
58066       {
58067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58068       };
58069     } catch (std::exception& e) {
58070       {
58071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58072       };
58073     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58074   }
58075 }
58076
58077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58078   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58079   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58080
58081   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58082   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58083   {
58084     try {
58085       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58086     } catch (std::out_of_range& e) {
58087       {
58088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58089       };
58090     } catch (std::exception& e) {
58091       {
58092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58093       };
58094     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58095   }
58096 }
58097
58098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58099   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58100   Dali::Actor arg2 ;
58101   //bool arg3 ;
58102   Dali::LayoutDirection::Type arg4 ;
58103   Dali::Actor *argp2 ;
58104
58105   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58106   argp2 = (Dali::Actor *)jarg2;
58107   if (!argp2) {
58108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58109     return ;
58110   }
58111   arg2 = *argp2;
58112   //arg3 = jarg3 ? true : false;
58113   arg4 = (Dali::LayoutDirection::Type)jarg4;
58114   {
58115     try {
58116       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58117     } catch (std::out_of_range& e) {
58118       {
58119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58120       };
58121     } catch (std::exception& e) {
58122       {
58123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58124       };
58125     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58126   }
58127 }
58128
58129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58130   void * jresult ;
58131   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58132
58133   {
58134     try {
58135       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58136     } catch (std::out_of_range& e) {
58137       {
58138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58139       };
58140     } catch (std::exception& e) {
58141       {
58142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58143       };
58144     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58145   }
58146   jresult = (void *)result;
58147   return jresult;
58148 }
58149
58150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58151   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58152
58153   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58154   {
58155     try {
58156       delete arg1;
58157     } catch (std::out_of_range& e) {
58158       {
58159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58160       };
58161     } catch (std::exception& e) {
58162       {
58163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58164       };
58165     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58166   }
58167 }
58168
58169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58170   unsigned int jresult ;
58171   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58172   bool result;
58173
58174   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58175   {
58176     try {
58177       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);
58178     } catch (std::out_of_range& e) {
58179       {
58180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58181       };
58182     } catch (std::exception& e) {
58183       {
58184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58185       };
58186     } catch (Dali::DaliException e) {
58187       {
58188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58189       };
58190     } catch (...) {
58191       {
58192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58193       };
58194     }
58195   }
58196
58197   jresult = result;
58198   return jresult;
58199 }
58200
58201
58202 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58203   unsigned long jresult ;
58204   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58205   std::size_t result;
58206
58207   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58208   {
58209     try {
58210       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);
58211     } catch (std::out_of_range& e) {
58212       {
58213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58214       };
58215     } catch (std::exception& e) {
58216       {
58217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58218       };
58219     } catch (Dali::DaliException e) {
58220       {
58221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58222       };
58223     } catch (...) {
58224       {
58225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58226       };
58227     }
58228   }
58229
58230   jresult = (unsigned long)result;
58231   return jresult;
58232 }
58233
58234
58235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58236   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58237   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58238
58239   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58240   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58241   {
58242     try {
58243       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58244     } catch (std::out_of_range& e) {
58245       {
58246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58247       };
58248     } catch (std::exception& e) {
58249       {
58250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58251       };
58252     } catch (Dali::DaliException e) {
58253       {
58254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58255       };
58256     } catch (...) {
58257       {
58258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58259       };
58260     }
58261   }
58262
58263 }
58264
58265
58266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58267   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58268   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58269
58270   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58271   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58272   {
58273     try {
58274       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58275     } catch (std::out_of_range& e) {
58276       {
58277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58278       };
58279     } catch (std::exception& e) {
58280       {
58281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58282       };
58283     } catch (Dali::DaliException e) {
58284       {
58285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58286       };
58287     } catch (...) {
58288       {
58289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58290       };
58291     }
58292   }
58293
58294 }
58295
58296
58297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58298   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58299   Dali::Actor arg2 ;
58300   bool arg3 ;
58301   Dali::DevelActor::VisibilityChange::Type arg4 ;
58302   Dali::Actor *argp2 ;
58303
58304   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58305   argp2 = (Dali::Actor *)jarg2;
58306   if (!argp2) {
58307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58308     return ;
58309   }
58310   arg2 = *argp2;
58311   arg3 = jarg3 ? true : false;
58312   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58313   {
58314     try {
58315       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58316     } catch (std::out_of_range& e) {
58317       {
58318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58319       };
58320     } catch (std::exception& e) {
58321       {
58322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58323       };
58324     } catch (Dali::DaliException e) {
58325       {
58326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58327       };
58328     } catch (...) {
58329       {
58330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58331       };
58332     }
58333   }
58334
58335 }
58336
58337
58338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58339   void * jresult ;
58340   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58341
58342   {
58343     try {
58344       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58345     } catch (std::out_of_range& e) {
58346       {
58347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58348       };
58349     } catch (std::exception& e) {
58350       {
58351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58352       };
58353     } catch (Dali::DaliException e) {
58354       {
58355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58356       };
58357     } catch (...) {
58358       {
58359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58360       };
58361     }
58362   }
58363
58364   jresult = (void *)result;
58365   return jresult;
58366 }
58367
58368
58369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58370   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58371
58372   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58373   {
58374     try {
58375       delete arg1;
58376     } catch (std::out_of_range& e) {
58377       {
58378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58379       };
58380     } catch (std::exception& e) {
58381       {
58382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58383       };
58384     } catch (Dali::DaliException e) {
58385       {
58386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58387       };
58388     } catch (...) {
58389       {
58390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58391       };
58392     }
58393   }
58394
58395 }
58396
58397
58398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58399   void * jresult ;
58400   Dali::Timer *result = 0 ;
58401
58402   {
58403     try {
58404       result = (Dali::Timer *)new Dali::Timer();
58405     } catch (std::out_of_range& e) {
58406       {
58407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58408       };
58409     } catch (std::exception& e) {
58410       {
58411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58412       };
58413     } catch (Dali::DaliException e) {
58414       {
58415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58416       };
58417     } catch (...) {
58418       {
58419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58420       };
58421     }
58422   }
58423
58424   jresult = (void *)result;
58425   return jresult;
58426 }
58427
58428
58429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58430   void * jresult ;
58431   unsigned int arg1 ;
58432   Dali::Timer result;
58433
58434   arg1 = (unsigned int)jarg1;
58435   {
58436     try {
58437       result = Dali::Timer::New(arg1);
58438     } catch (std::out_of_range& e) {
58439       {
58440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58441       };
58442     } catch (std::exception& e) {
58443       {
58444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58445       };
58446     } catch (Dali::DaliException e) {
58447       {
58448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58449       };
58450     } catch (...) {
58451       {
58452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58453       };
58454     }
58455   }
58456
58457   jresult = new Dali::Timer((const Dali::Timer &)result);
58458   return jresult;
58459 }
58460
58461
58462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58463   void * jresult ;
58464   Dali::Timer *arg1 = 0 ;
58465   Dali::Timer *result = 0 ;
58466
58467   arg1 = (Dali::Timer *)jarg1;
58468   if (!arg1) {
58469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58470     return 0;
58471   }
58472   {
58473     try {
58474       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58475     } catch (std::out_of_range& e) {
58476       {
58477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58478       };
58479     } catch (std::exception& e) {
58480       {
58481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58482       };
58483     } catch (Dali::DaliException e) {
58484       {
58485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58486       };
58487     } catch (...) {
58488       {
58489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58490       };
58491     }
58492   }
58493
58494   jresult = (void *)result;
58495   return jresult;
58496 }
58497
58498
58499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58500   void * jresult ;
58501   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58502   Dali::Timer *arg2 = 0 ;
58503   Dali::Timer *result = 0 ;
58504
58505   arg1 = (Dali::Timer *)jarg1;
58506   arg2 = (Dali::Timer *)jarg2;
58507   if (!arg2) {
58508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58509     return 0;
58510   }
58511   {
58512     try {
58513       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58514     } catch (std::out_of_range& e) {
58515       {
58516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58517       };
58518     } catch (std::exception& e) {
58519       {
58520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58521       };
58522     } catch (Dali::DaliException e) {
58523       {
58524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58525       };
58526     } catch (...) {
58527       {
58528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58529       };
58530     }
58531   }
58532
58533   jresult = (void *)result;
58534   return jresult;
58535 }
58536
58537
58538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58539   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58540
58541   arg1 = (Dali::Timer *)jarg1;
58542   {
58543     try {
58544       delete arg1;
58545     } catch (std::out_of_range& e) {
58546       {
58547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58548       };
58549     } catch (std::exception& e) {
58550       {
58551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58552       };
58553     } catch (Dali::DaliException e) {
58554       {
58555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58556       };
58557     } catch (...) {
58558       {
58559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58560       };
58561     }
58562   }
58563
58564 }
58565
58566
58567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58568   void * jresult ;
58569   Dali::BaseHandle arg1 ;
58570   Dali::BaseHandle *argp1 ;
58571   Dali::Timer result;
58572
58573   argp1 = (Dali::BaseHandle *)jarg1;
58574   if (!argp1) {
58575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58576     return 0;
58577   }
58578   arg1 = *argp1;
58579   {
58580     try {
58581       result = Dali::Timer::DownCast(arg1);
58582     } catch (std::out_of_range& e) {
58583       {
58584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58585       };
58586     } catch (std::exception& e) {
58587       {
58588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58589       };
58590     } catch (Dali::DaliException e) {
58591       {
58592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58593       };
58594     } catch (...) {
58595       {
58596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58597       };
58598     }
58599   }
58600
58601   jresult = new Dali::Timer((const Dali::Timer &)result);
58602   return jresult;
58603 }
58604
58605
58606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58607   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58608
58609   arg1 = (Dali::Timer *)jarg1;
58610   {
58611     try {
58612       (arg1)->Start();
58613     } catch (std::out_of_range& e) {
58614       {
58615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58616       };
58617     } catch (std::exception& e) {
58618       {
58619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58620       };
58621     } catch (Dali::DaliException e) {
58622       {
58623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58624       };
58625     } catch (...) {
58626       {
58627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58628       };
58629     }
58630   }
58631
58632 }
58633
58634
58635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58636   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58637
58638   arg1 = (Dali::Timer *)jarg1;
58639   {
58640     try {
58641       (arg1)->Stop();
58642     } catch (std::out_of_range& e) {
58643       {
58644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58645       };
58646     } catch (std::exception& e) {
58647       {
58648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58649       };
58650     } catch (Dali::DaliException e) {
58651       {
58652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58653       };
58654     } catch (...) {
58655       {
58656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58657       };
58658     }
58659   }
58660
58661 }
58662
58663
58664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58665   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58666   unsigned int arg2 ;
58667
58668   arg1 = (Dali::Timer *)jarg1;
58669   arg2 = (unsigned int)jarg2;
58670   {
58671     try {
58672       (arg1)->SetInterval(arg2);
58673     } catch (std::out_of_range& e) {
58674       {
58675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58676       };
58677     } catch (std::exception& e) {
58678       {
58679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58680       };
58681     } catch (Dali::DaliException e) {
58682       {
58683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58684       };
58685     } catch (...) {
58686       {
58687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58688       };
58689     }
58690   }
58691
58692 }
58693
58694
58695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58696   unsigned int jresult ;
58697   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58698   unsigned int result;
58699
58700   arg1 = (Dali::Timer *)jarg1;
58701   {
58702     try {
58703       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58704     } catch (std::out_of_range& e) {
58705       {
58706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58707       };
58708     } catch (std::exception& e) {
58709       {
58710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58711       };
58712     } catch (Dali::DaliException e) {
58713       {
58714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58715       };
58716     } catch (...) {
58717       {
58718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58719       };
58720     }
58721   }
58722
58723   jresult = result;
58724   return jresult;
58725 }
58726
58727
58728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58729   unsigned int jresult ;
58730   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58731   bool result;
58732
58733   arg1 = (Dali::Timer *)jarg1;
58734   {
58735     try {
58736       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58737     } catch (std::out_of_range& e) {
58738       {
58739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58740       };
58741     } catch (std::exception& e) {
58742       {
58743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58744       };
58745     } catch (Dali::DaliException e) {
58746       {
58747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58748       };
58749     } catch (...) {
58750       {
58751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58752       };
58753     }
58754   }
58755
58756   jresult = result;
58757   return jresult;
58758 }
58759
58760
58761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58762   void * jresult ;
58763   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58764   Dali::Timer::TimerSignalType *result = 0 ;
58765
58766   arg1 = (Dali::Timer *)jarg1;
58767   {
58768     try {
58769       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58770     } catch (std::out_of_range& e) {
58771       {
58772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58773       };
58774     } catch (std::exception& e) {
58775       {
58776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58777       };
58778     } catch (Dali::DaliException e) {
58779       {
58780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58781       };
58782     } catch (...) {
58783       {
58784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58785       };
58786     }
58787   }
58788
58789   jresult = (void *)result;
58790   return jresult;
58791 }
58792
58793
58794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58795   void * jresult ;
58796   Dali::DragAndDropDetector *result = 0 ;
58797
58798   {
58799     try {
58800       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58801     } catch (std::out_of_range& e) {
58802       {
58803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58804       };
58805     } catch (std::exception& e) {
58806       {
58807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58808       };
58809     } catch (Dali::DaliException e) {
58810       {
58811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58812       };
58813     } catch (...) {
58814       {
58815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58816       };
58817     }
58818   }
58819
58820   jresult = (void *)result;
58821   return jresult;
58822 }
58823
58824
58825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58826   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58827
58828   arg1 = (Dali::DragAndDropDetector *)jarg1;
58829   {
58830     try {
58831       delete arg1;
58832     } catch (std::out_of_range& e) {
58833       {
58834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58835       };
58836     } catch (std::exception& e) {
58837       {
58838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58839       };
58840     } catch (Dali::DaliException e) {
58841       {
58842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58843       };
58844     } catch (...) {
58845       {
58846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58847       };
58848     }
58849   }
58850
58851 }
58852
58853
58854 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58855   char * jresult ;
58856   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58857   std::string *result = 0 ;
58858
58859   arg1 = (Dali::DragAndDropDetector *)jarg1;
58860   {
58861     try {
58862       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58863     } catch (std::out_of_range& e) {
58864       {
58865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58866       };
58867     } catch (std::exception& e) {
58868       {
58869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58870       };
58871     } catch (Dali::DaliException e) {
58872       {
58873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58874       };
58875     } catch (...) {
58876       {
58877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58878       };
58879     }
58880   }
58881
58882   jresult = SWIG_csharp_string_callback(result->c_str());
58883   return jresult;
58884 }
58885
58886
58887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58888   void * jresult ;
58889   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58890   Dali::Vector2 result;
58891
58892   arg1 = (Dali::DragAndDropDetector *)jarg1;
58893   {
58894     try {
58895       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58896     } catch (std::out_of_range& e) {
58897       {
58898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58899       };
58900     } catch (std::exception& e) {
58901       {
58902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58903       };
58904     } catch (Dali::DaliException e) {
58905       {
58906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58907       };
58908     } catch (...) {
58909       {
58910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58911       };
58912     }
58913   }
58914
58915   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58916   return jresult;
58917 }
58918
58919
58920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58921   void * jresult ;
58922   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58923   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58924
58925   arg1 = (Dali::DragAndDropDetector *)jarg1;
58926   {
58927     try {
58928       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58929     } catch (std::out_of_range& e) {
58930       {
58931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58932       };
58933     } catch (std::exception& e) {
58934       {
58935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58936       };
58937     } catch (Dali::DaliException e) {
58938       {
58939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58940       };
58941     } catch (...) {
58942       {
58943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58944       };
58945     }
58946   }
58947
58948   jresult = (void *)result;
58949   return jresult;
58950 }
58951
58952
58953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58954   void * jresult ;
58955   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58956   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58957
58958   arg1 = (Dali::DragAndDropDetector *)jarg1;
58959   {
58960     try {
58961       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58962     } catch (std::out_of_range& e) {
58963       {
58964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58965       };
58966     } catch (std::exception& e) {
58967       {
58968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58969       };
58970     } catch (Dali::DaliException e) {
58971       {
58972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58973       };
58974     } catch (...) {
58975       {
58976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58977       };
58978     }
58979   }
58980
58981   jresult = (void *)result;
58982   return jresult;
58983 }
58984
58985
58986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58987   void * jresult ;
58988   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58989   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58990
58991   arg1 = (Dali::DragAndDropDetector *)jarg1;
58992   {
58993     try {
58994       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58995     } catch (std::out_of_range& e) {
58996       {
58997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58998       };
58999     } catch (std::exception& e) {
59000       {
59001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59002       };
59003     } catch (Dali::DaliException e) {
59004       {
59005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59006       };
59007     } catch (...) {
59008       {
59009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59010       };
59011     }
59012   }
59013
59014   jresult = (void *)result;
59015   return jresult;
59016 }
59017
59018
59019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
59020   void * jresult ;
59021   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
59022   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
59023
59024   arg1 = (Dali::DragAndDropDetector *)jarg1;
59025   {
59026     try {
59027       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
59028     } catch (std::out_of_range& e) {
59029       {
59030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59031       };
59032     } catch (std::exception& e) {
59033       {
59034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59035       };
59036     } catch (Dali::DaliException e) {
59037       {
59038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59039       };
59040     } catch (...) {
59041       {
59042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59043       };
59044     }
59045   }
59046
59047   jresult = (void *)result;
59048   return jresult;
59049 }
59050
59051
59052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
59053   void * jresult ;
59054   Dali::ApplicationExtensions *result = 0 ;
59055
59056   {
59057     try {
59058       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
59059     } catch (std::out_of_range& e) {
59060       {
59061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59062       };
59063     } catch (std::exception& e) {
59064       {
59065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59066       };
59067     } catch (Dali::DaliException e) {
59068       {
59069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59070       };
59071     } catch (...) {
59072       {
59073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59074       };
59075     }
59076   }
59077
59078   jresult = (void *)result;
59079   return jresult;
59080 }
59081
59082
59083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
59084   void * jresult ;
59085   Dali::Application *arg1 = (Dali::Application *) 0 ;
59086   Dali::ApplicationExtensions *result = 0 ;
59087
59088   arg1 = (Dali::Application *)jarg1;
59089   {
59090     try {
59091       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
59092     } catch (std::out_of_range& e) {
59093       {
59094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59095       };
59096     } catch (std::exception& e) {
59097       {
59098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59099       };
59100     } catch (Dali::DaliException e) {
59101       {
59102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59103       };
59104     } catch (...) {
59105       {
59106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59107       };
59108     }
59109   }
59110
59111   jresult = (void *)result;
59112   return jresult;
59113 }
59114
59115
59116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
59117   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59118
59119   arg1 = (Dali::ApplicationExtensions *)jarg1;
59120   {
59121     try {
59122       delete arg1;
59123     } catch (std::out_of_range& e) {
59124       {
59125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59126       };
59127     } catch (std::exception& e) {
59128       {
59129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59130       };
59131     } catch (Dali::DaliException e) {
59132       {
59133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59134       };
59135     } catch (...) {
59136       {
59137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59138       };
59139     }
59140   }
59141
59142 }
59143
59144
59145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
59146   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59147
59148   arg1 = (Dali::ApplicationExtensions *)jarg1;
59149   {
59150     try {
59151       (arg1)->Init();
59152     } catch (std::out_of_range& e) {
59153       {
59154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59155       };
59156     } catch (std::exception& e) {
59157       {
59158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59159       };
59160     } catch (Dali::DaliException e) {
59161       {
59162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59163       };
59164     } catch (...) {
59165       {
59166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59167       };
59168     }
59169   }
59170
59171 }
59172
59173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
59174   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59175
59176   arg1 = (Dali::ApplicationExtensions *)jarg1;
59177   {
59178     try {
59179       (arg1)->Start();
59180     } catch (std::out_of_range& e) {
59181       {
59182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59183       };
59184     } catch (std::exception& e) {
59185       {
59186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59187       };
59188     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
59189   }
59190 }
59191
59192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
59193   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59194
59195   arg1 = (Dali::ApplicationExtensions *)jarg1;
59196   {
59197     try {
59198       (arg1)->Terminate();
59199     } catch (std::out_of_range& e) {
59200       {
59201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59202       };
59203     } catch (std::exception& e) {
59204       {
59205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59206       };
59207     } catch (Dali::DaliException e) {
59208       {
59209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59210       };
59211     } catch (...) {
59212       {
59213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59214       };
59215     }
59216   }
59217
59218 }
59219
59220
59221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59222   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59223
59224   arg1 = (Dali::ApplicationExtensions *)jarg1;
59225   {
59226     try {
59227       (arg1)->Pause();
59228     } catch (std::out_of_range& e) {
59229       {
59230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59231       };
59232     } catch (std::exception& e) {
59233       {
59234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59235       };
59236     } catch (Dali::DaliException e) {
59237       {
59238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59239       };
59240     } catch (...) {
59241       {
59242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59243       };
59244     }
59245   }
59246
59247 }
59248
59249
59250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59251   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59252
59253   arg1 = (Dali::ApplicationExtensions *)jarg1;
59254   {
59255     try {
59256       (arg1)->Resume();
59257     } catch (std::out_of_range& e) {
59258       {
59259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59260       };
59261     } catch (std::exception& e) {
59262       {
59263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59264       };
59265     } catch (Dali::DaliException e) {
59266       {
59267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59268       };
59269     } catch (...) {
59270       {
59271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59272       };
59273     }
59274   }
59275
59276 }
59277
59278
59279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59280   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59281
59282   arg1 = (Dali::ApplicationExtensions *)jarg1;
59283   {
59284     try {
59285       (arg1)->LanguageChange();
59286     } catch (std::out_of_range& e) {
59287       {
59288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59289       };
59290     } catch (std::exception& e) {
59291       {
59292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59293       };
59294     } catch (Dali::DaliException e) {
59295       {
59296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59297       };
59298     } catch (...) {
59299       {
59300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59301       };
59302     }
59303   }
59304
59305 }
59306
59307
59308
59309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59310   unsigned int jresult ;
59311   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59312   bool result;
59313
59314   arg1 = (Dali::Signal< bool () > *)jarg1;
59315   {
59316     try {
59317       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59318     } catch (std::out_of_range& e) {
59319       {
59320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59321       };
59322     } catch (std::exception& e) {
59323       {
59324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59325       };
59326     } catch (Dali::DaliException e) {
59327       {
59328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59329       };
59330     } catch (...) {
59331       {
59332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59333       };
59334     }
59335   }
59336
59337   jresult = result;
59338   return jresult;
59339 }
59340
59341
59342 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59343   unsigned long jresult ;
59344   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59345   std::size_t result;
59346
59347   arg1 = (Dali::Signal< bool () > *)jarg1;
59348   {
59349     try {
59350       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59351     } catch (std::out_of_range& e) {
59352       {
59353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59354       };
59355     } catch (std::exception& e) {
59356       {
59357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59358       };
59359     } catch (Dali::DaliException e) {
59360       {
59361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59362       };
59363     } catch (...) {
59364       {
59365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59366       };
59367     }
59368   }
59369
59370   jresult = (unsigned long)result;
59371   return jresult;
59372 }
59373
59374
59375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59376   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59377   bool (*arg2)() = (bool (*)()) 0 ;
59378
59379   arg1 = (Dali::Signal< bool () > *)jarg1;
59380   arg2 = (bool (*)())jarg2;
59381   {
59382     try {
59383       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59384     } catch (std::out_of_range& e) {
59385       {
59386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59387       };
59388     } catch (std::exception& e) {
59389       {
59390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59391       };
59392     } catch (Dali::DaliException e) {
59393       {
59394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59395       };
59396     } catch (...) {
59397       {
59398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59399       };
59400     }
59401   }
59402
59403 }
59404
59405
59406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59407   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59408   bool (*arg2)() = (bool (*)()) 0 ;
59409
59410   arg1 = (Dali::Signal< bool () > *)jarg1;
59411   arg2 = (bool (*)())jarg2;
59412   {
59413     try {
59414       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59415     } catch (std::out_of_range& e) {
59416       {
59417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59418       };
59419     } catch (std::exception& e) {
59420       {
59421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59422       };
59423     } catch (Dali::DaliException e) {
59424       {
59425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59426       };
59427     } catch (...) {
59428       {
59429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59430       };
59431     }
59432   }
59433
59434 }
59435
59436
59437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59438   unsigned int jresult ;
59439   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59440   bool result;
59441
59442   arg1 = (Dali::Signal< bool () > *)jarg1;
59443   {
59444     try {
59445       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59446     } catch (std::out_of_range& e) {
59447       {
59448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59449       };
59450     } catch (std::exception& e) {
59451       {
59452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59453       };
59454     } catch (Dali::DaliException e) {
59455       {
59456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59457       };
59458     } catch (...) {
59459       {
59460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59461       };
59462     }
59463   }
59464
59465   jresult = result;
59466   return jresult;
59467 }
59468
59469
59470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59471   void * jresult ;
59472   Dali::Signal< bool () > *result = 0 ;
59473
59474   {
59475     try {
59476       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59477     } catch (std::out_of_range& e) {
59478       {
59479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59480       };
59481     } catch (std::exception& e) {
59482       {
59483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59484       };
59485     } catch (Dali::DaliException e) {
59486       {
59487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59488       };
59489     } catch (...) {
59490       {
59491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59492       };
59493     }
59494   }
59495
59496   jresult = (void *)result;
59497   return jresult;
59498 }
59499
59500
59501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59502   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59503
59504   arg1 = (Dali::Signal< bool () > *)jarg1;
59505   {
59506     try {
59507       delete arg1;
59508     } catch (std::out_of_range& e) {
59509       {
59510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59511       };
59512     } catch (std::exception& e) {
59513       {
59514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59515       };
59516     } catch (Dali::DaliException e) {
59517       {
59518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59519       };
59520     } catch (...) {
59521       {
59522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59523       };
59524     }
59525   }
59526
59527 }
59528
59529
59530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59531   int jresult ;
59532   int result;
59533
59534   {
59535     try {
59536       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59537     } catch (std::out_of_range& e) {
59538       {
59539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59540       };
59541     } catch (std::exception& e) {
59542       {
59543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59544       };
59545     } catch (Dali::DaliException e) {
59546       {
59547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59548       };
59549     } catch (...) {
59550       {
59551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59552       };
59553     }
59554   }
59555
59556   jresult = (int)result;
59557   return jresult;
59558 }
59559
59560
59561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59562   int jresult ;
59563   int result;
59564
59565   {
59566     try {
59567       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59568     } catch (std::out_of_range& e) {
59569       {
59570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59571       };
59572     } catch (std::exception& e) {
59573       {
59574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59575       };
59576     } catch (Dali::DaliException e) {
59577       {
59578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59579       };
59580     } catch (...) {
59581       {
59582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59583       };
59584     }
59585   }
59586
59587   jresult = (int)result;
59588   return jresult;
59589 }
59590
59591
59592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59593   int jresult ;
59594   int result;
59595
59596   {
59597     try {
59598       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59599     } catch (std::out_of_range& e) {
59600       {
59601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59602       };
59603     } catch (std::exception& e) {
59604       {
59605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59606       };
59607     } catch (Dali::DaliException e) {
59608       {
59609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59610       };
59611     } catch (...) {
59612       {
59613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59614       };
59615     }
59616   }
59617
59618   jresult = (int)result;
59619   return jresult;
59620 }
59621
59622
59623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59624   int jresult ;
59625   int result;
59626
59627   {
59628     try {
59629       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59630     } catch (std::out_of_range& e) {
59631       {
59632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59633       };
59634     } catch (std::exception& e) {
59635       {
59636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59637       };
59638     } catch (Dali::DaliException e) {
59639       {
59640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59641       };
59642     } catch (...) {
59643       {
59644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59645       };
59646     }
59647   }
59648
59649   jresult = (int)result;
59650   return jresult;
59651 }
59652
59653
59654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59655   int jresult ;
59656   int result;
59657
59658   {
59659     try {
59660       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59661     } catch (std::out_of_range& e) {
59662       {
59663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59664       };
59665     } catch (std::exception& e) {
59666       {
59667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59668       };
59669     } catch (Dali::DaliException e) {
59670       {
59671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59672       };
59673     } catch (...) {
59674       {
59675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59676       };
59677     }
59678   }
59679
59680   jresult = (int)result;
59681   return jresult;
59682 }
59683
59684
59685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59686   int jresult ;
59687   int result;
59688
59689   {
59690     try {
59691       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59692     } catch (std::out_of_range& e) {
59693       {
59694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59695       };
59696     } catch (std::exception& e) {
59697       {
59698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59699       };
59700     } catch (Dali::DaliException e) {
59701       {
59702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59703       };
59704     } catch (...) {
59705       {
59706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59707       };
59708     }
59709   }
59710
59711   jresult = (int)result;
59712   return jresult;
59713 }
59714
59715
59716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59717   int jresult ;
59718   int result;
59719
59720   {
59721     try {
59722       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59723     } catch (std::out_of_range& e) {
59724       {
59725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59726       };
59727     } catch (std::exception& e) {
59728       {
59729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59730       };
59731     } catch (Dali::DaliException e) {
59732       {
59733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59734       };
59735     } catch (...) {
59736       {
59737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59738       };
59739     }
59740   }
59741
59742   jresult = (int)result;
59743   return jresult;
59744 }
59745
59746
59747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59748   int jresult ;
59749   int result;
59750
59751   {
59752     try {
59753       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59754     } catch (std::out_of_range& e) {
59755       {
59756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59757       };
59758     } catch (std::exception& e) {
59759       {
59760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59761       };
59762     } catch (Dali::DaliException e) {
59763       {
59764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59765       };
59766     } catch (...) {
59767       {
59768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59769       };
59770     }
59771   }
59772
59773   jresult = (int)result;
59774   return jresult;
59775 }
59776
59777
59778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59779   int jresult ;
59780   int result;
59781
59782   {
59783     try {
59784       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59785     } catch (std::out_of_range& e) {
59786       {
59787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59788       };
59789     } catch (std::exception& e) {
59790       {
59791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59792       };
59793     } catch (Dali::DaliException e) {
59794       {
59795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59796       };
59797     } catch (...) {
59798       {
59799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59800       };
59801     }
59802   }
59803
59804   jresult = (int)result;
59805   return jresult;
59806 }
59807
59808
59809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59810   int jresult ;
59811   int result;
59812
59813   {
59814     try {
59815       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59816     } catch (std::out_of_range& e) {
59817       {
59818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59819       };
59820     } catch (std::exception& e) {
59821       {
59822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59823       };
59824     } catch (Dali::DaliException e) {
59825       {
59826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59827       };
59828     } catch (...) {
59829       {
59830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59831       };
59832     }
59833   }
59834
59835   jresult = (int)result;
59836   return jresult;
59837 }
59838
59839
59840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59841   int jresult ;
59842   int result;
59843
59844   {
59845     try {
59846       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59847     } catch (std::out_of_range& e) {
59848       {
59849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59850       };
59851     } catch (std::exception& e) {
59852       {
59853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59854       };
59855     } catch (Dali::DaliException e) {
59856       {
59857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59858       };
59859     } catch (...) {
59860       {
59861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59862       };
59863     }
59864   }
59865
59866   jresult = (int)result;
59867   return jresult;
59868 }
59869
59870
59871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59872   int jresult ;
59873   int result;
59874
59875   {
59876     try {
59877       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59878     } catch (std::out_of_range& e) {
59879       {
59880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59881       };
59882     } catch (std::exception& e) {
59883       {
59884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59885       };
59886     } catch (Dali::DaliException e) {
59887       {
59888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59889       };
59890     } catch (...) {
59891       {
59892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59893       };
59894     }
59895   }
59896
59897   jresult = (int)result;
59898   return jresult;
59899 }
59900
59901
59902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59903   int jresult ;
59904   int result;
59905
59906   {
59907     try {
59908       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59909     } catch (std::out_of_range& e) {
59910       {
59911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59912       };
59913     } catch (std::exception& e) {
59914       {
59915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59916       };
59917     } catch (Dali::DaliException e) {
59918       {
59919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59920       };
59921     } catch (...) {
59922       {
59923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59924       };
59925     }
59926   }
59927
59928   jresult = (int)result;
59929   return jresult;
59930 }
59931
59932
59933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59934   int jresult ;
59935   int result;
59936
59937   {
59938     try {
59939       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59940     } catch (std::out_of_range& e) {
59941       {
59942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59943       };
59944     } catch (std::exception& e) {
59945       {
59946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59947       };
59948     } catch (Dali::DaliException e) {
59949       {
59950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59951       };
59952     } catch (...) {
59953       {
59954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59955       };
59956     }
59957   }
59958
59959   jresult = (int)result;
59960   return jresult;
59961 }
59962
59963
59964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59965   int jresult ;
59966   int result;
59967
59968   {
59969     try {
59970       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59971     } catch (std::out_of_range& e) {
59972       {
59973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59974       };
59975     } catch (std::exception& e) {
59976       {
59977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59978       };
59979     } catch (Dali::DaliException e) {
59980       {
59981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59982       };
59983     } catch (...) {
59984       {
59985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59986       };
59987     }
59988   }
59989
59990   jresult = (int)result;
59991   return jresult;
59992 }
59993
59994
59995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59996   int jresult ;
59997   int result;
59998
59999   {
60000     try {
60001       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
60002     } catch (std::out_of_range& e) {
60003       {
60004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60005       };
60006     } catch (std::exception& e) {
60007       {
60008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60009       };
60010     } catch (Dali::DaliException e) {
60011       {
60012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60013       };
60014     } catch (...) {
60015       {
60016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60017       };
60018     }
60019   }
60020
60021   jresult = (int)result;
60022   return jresult;
60023 }
60024
60025
60026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
60027   int jresult ;
60028   int result;
60029
60030   {
60031     try {
60032       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
60033     } catch (std::out_of_range& e) {
60034       {
60035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60036       };
60037     } catch (std::exception& e) {
60038       {
60039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60040       };
60041     } catch (Dali::DaliException e) {
60042       {
60043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60044       };
60045     } catch (...) {
60046       {
60047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60048       };
60049     }
60050   }
60051
60052   jresult = (int)result;
60053   return jresult;
60054 }
60055
60056
60057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
60058   int jresult ;
60059   int result;
60060
60061   {
60062     try {
60063       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
60064     } catch (std::out_of_range& e) {
60065       {
60066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60067       };
60068     } catch (std::exception& e) {
60069       {
60070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60071       };
60072     } catch (Dali::DaliException e) {
60073       {
60074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60075       };
60076     } catch (...) {
60077       {
60078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60079       };
60080     }
60081   }
60082
60083   jresult = (int)result;
60084   return jresult;
60085 }
60086
60087
60088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
60089   int jresult ;
60090   int result;
60091
60092   {
60093     try {
60094       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
60095     } catch (std::out_of_range& e) {
60096       {
60097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60098       };
60099     } catch (std::exception& e) {
60100       {
60101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60102       };
60103     } catch (Dali::DaliException e) {
60104       {
60105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60106       };
60107     } catch (...) {
60108       {
60109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60110       };
60111     }
60112   }
60113
60114   jresult = (int)result;
60115   return jresult;
60116 }
60117
60118
60119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
60120   int jresult ;
60121   int result;
60122
60123   {
60124     try {
60125       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
60126     } catch (std::out_of_range& e) {
60127       {
60128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60129       };
60130     } catch (std::exception& e) {
60131       {
60132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60133       };
60134     } catch (Dali::DaliException e) {
60135       {
60136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60137       };
60138     } catch (...) {
60139       {
60140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60141       };
60142     }
60143   }
60144
60145   jresult = (int)result;
60146   return jresult;
60147 }
60148
60149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
60150   int jresult ;
60151   int result;
60152
60153   {
60154     try {
60155       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
60156     } catch (std::out_of_range& e) {
60157       {
60158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60159       };
60160     } catch (std::exception& e) {
60161       {
60162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60163       };
60164     } catch (Dali::DaliException e) {
60165       {
60166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60167       };
60168     } catch (...) {
60169       {
60170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60171       };
60172     }
60173   }
60174
60175   jresult = (int)result;
60176   return jresult;
60177 }
60178
60179
60180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
60181   int jresult ;
60182   int result;
60183   {
60184     try
60185     {
60186       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
60187     } catch (std::out_of_range& e) {
60188       {
60189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60190       };
60191     } catch (std::exception& e) {
60192       {
60193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60194       };
60195     } catch (Dali::DaliException e) {
60196       {
60197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60198       };
60199     } catch (...) {
60200       {
60201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60202       };
60203     }
60204   }
60205
60206   jresult = (int)result;
60207   return jresult;
60208 }
60209
60210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
60211   int jresult ;
60212   int result;
60213   {
60214     try
60215     {
60216       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
60217     } catch (std::out_of_range& e) {
60218       {
60219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60220       };
60221     } catch (std::exception& e) {
60222       {
60223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60224       };
60225     } catch (Dali::DaliException e) {
60226       {
60227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60228       };
60229     } catch (...) {
60230       {
60231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60232       };
60233     }
60234   }
60235
60236   jresult = (int)result;
60237   return jresult;
60238 }
60239
60240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60241   int jresult ;
60242   int result;
60243   {
60244     try
60245     {
60246       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
60247     } catch (std::out_of_range& e) {
60248       {
60249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60250       };
60251     } catch (std::exception& e) {
60252       {
60253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60254       };
60255     } catch (Dali::DaliException e) {
60256       {
60257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60258       };
60259     } catch (...) {
60260       {
60261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60262       };
60263     }
60264   }
60265
60266   jresult = (int)result;
60267   return jresult;
60268 }
60269
60270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
60271   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
60272 }
60273
60274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60275   int jresult ;
60276   int result;
60277   {
60278     try
60279     {
60280       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60281     } catch (std::out_of_range& e) {
60282       {
60283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60284       };
60285     } catch (std::exception& e) {
60286       {
60287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60288       };
60289     } catch (Dali::DaliException e) {
60290       {
60291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60292       };
60293     } catch (...) {
60294       {
60295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60296       };
60297     }
60298   }
60299
60300   jresult = (int)result;
60301   return jresult;
60302 }
60303
60304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60305   int jresult ;
60306   int result;
60307   {
60308     try
60309     {
60310       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60311     } catch (std::out_of_range& e) {
60312       {
60313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60314       };
60315     } catch (std::exception& e) {
60316       {
60317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60318       };
60319     } catch (Dali::DaliException e) {
60320       {
60321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60322       };
60323     } catch (...) {
60324       {
60325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60326       };
60327     }
60328   }
60329
60330   jresult = (int)result;
60331   return jresult;
60332 }
60333
60334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60335   int jresult ;
60336   int result;
60337
60338   {
60339     try {
60340       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60341     } catch (std::out_of_range& e) {
60342       {
60343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60344       };
60345     } catch (std::exception& e) {
60346       {
60347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60348       };
60349     } catch (Dali::DaliException e) {
60350       {
60351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60352       };
60353     } catch (...) {
60354       {
60355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60356       };
60357     }
60358   }
60359
60360   jresult = (int)result;
60361   return jresult;
60362 }
60363
60364
60365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60366   int jresult ;
60367   int result;
60368
60369   {
60370     try {
60371       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60372     } catch (std::out_of_range& e) {
60373       {
60374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60375       };
60376     } catch (std::exception& e) {
60377       {
60378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60379       };
60380     } catch (Dali::DaliException e) {
60381       {
60382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60383       };
60384     } catch (...) {
60385       {
60386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60387       };
60388     }
60389   }
60390
60391   jresult = (int)result;
60392   return jresult;
60393 }
60394
60395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60396   int jresult ;
60397   int result;
60398   {
60399     try
60400     {
60401       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60402     } catch (std::out_of_range& e) {
60403       {
60404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60405       };
60406     } catch (std::exception& e) {
60407       {
60408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60409       };
60410     } catch (...) {
60411       {
60412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60413       };
60414     }
60415   }
60416   jresult = (int)result;
60417   return jresult;
60418 }
60419
60420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60421   int jresult ;
60422   int result;
60423   {
60424     try
60425     {
60426       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60427     } catch (std::out_of_range& e) {
60428       {
60429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60430       };
60431     } catch (std::exception& e) {
60432       {
60433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60434       };
60435     } catch (...) {
60436       {
60437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60438       };
60439     }
60440   }
60441   jresult = (int)result;
60442   return jresult;
60443 }
60444
60445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60446   int jresult ;
60447   int result;
60448   {
60449     try
60450     {
60451       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60452     } catch (std::out_of_range& e) {
60453       {
60454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60455       };
60456     } catch (std::exception& e) {
60457       {
60458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60459       };
60460     } catch (...) {
60461       {
60462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60463       };
60464     }
60465   }
60466   jresult = (int)result;
60467   return jresult;
60468 }
60469
60470
60471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60472   int jresult ;
60473   int result;
60474   {
60475     try
60476     {
60477       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60478     } catch (std::out_of_range& e) {
60479       {
60480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60481       };
60482     } catch (std::exception& e) {
60483       {
60484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60485       };
60486     } catch (...) {
60487       {
60488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60489       };
60490     }
60491   }
60492   jresult = (int)result;
60493   return jresult;
60494 }
60495
60496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60497   int jresult ;
60498   int result;
60499   {
60500     try
60501     {
60502       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60503     } catch (std::out_of_range& e) {
60504       {
60505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60506       };
60507     } catch (std::exception& e) {
60508       {
60509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60510       };
60511     } catch (...) {
60512       {
60513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60514       };
60515     }
60516   }
60517   jresult = (int)result;
60518   return jresult;
60519 }
60520
60521
60522
60523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60524   int jresult ;
60525   int result;
60526
60527   {
60528     try {
60529       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60530     } catch (std::out_of_range& e) {
60531       {
60532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60533       };
60534     } catch (std::exception& e) {
60535       {
60536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60537       };
60538     } catch (Dali::DaliException e) {
60539       {
60540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60541       };
60542     } catch (...) {
60543       {
60544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60545       };
60546     }
60547   }
60548
60549   jresult = (int)result;
60550   return jresult;
60551 }
60552
60553
60554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60555   int jresult ;
60556   int result;
60557
60558   {
60559     try {
60560       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60561     } catch (std::out_of_range& e) {
60562       {
60563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60564       };
60565     } catch (std::exception& e) {
60566       {
60567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60568       };
60569     } catch (Dali::DaliException e) {
60570       {
60571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60572       };
60573     } catch (...) {
60574       {
60575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60576       };
60577     }
60578   }
60579
60580   jresult = (int)result;
60581   return jresult;
60582 }
60583
60584
60585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60586   int jresult ;
60587   int result;
60588
60589   {
60590     try {
60591       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60592     } catch (std::out_of_range& e) {
60593       {
60594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60595       };
60596     } catch (std::exception& e) {
60597       {
60598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60599       };
60600     } catch (Dali::DaliException e) {
60601       {
60602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60603       };
60604     } catch (...) {
60605       {
60606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60607       };
60608     }
60609   }
60610
60611   jresult = (int)result;
60612   return jresult;
60613 }
60614
60615
60616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60617   int jresult ;
60618   int result;
60619
60620   {
60621     try {
60622       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60623     } catch (std::out_of_range& e) {
60624       {
60625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60626       };
60627     } catch (std::exception& e) {
60628       {
60629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60630       };
60631     } catch (Dali::DaliException e) {
60632       {
60633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60634       };
60635     } catch (...) {
60636       {
60637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60638       };
60639     }
60640   }
60641
60642   jresult = (int)result;
60643   return jresult;
60644 }
60645
60646
60647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60648   int jresult ;
60649   int result;
60650
60651   {
60652     try {
60653       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60654     } catch (std::out_of_range& e) {
60655       {
60656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60657       };
60658     } catch (std::exception& e) {
60659       {
60660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60661       };
60662     } catch (Dali::DaliException e) {
60663       {
60664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60665       };
60666     } catch (...) {
60667       {
60668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60669       };
60670     }
60671   }
60672
60673   jresult = (int)result;
60674   return jresult;
60675 }
60676
60677
60678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60679   int jresult ;
60680   int result;
60681
60682   {
60683     try {
60684       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60685     } catch (std::out_of_range& e) {
60686       {
60687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60688       };
60689     } catch (std::exception& e) {
60690       {
60691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60692       };
60693     } catch (Dali::DaliException e) {
60694       {
60695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60696       };
60697     } catch (...) {
60698       {
60699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60700       };
60701     }
60702   }
60703
60704   jresult = (int)result;
60705   return jresult;
60706 }
60707
60708
60709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60710   int jresult ;
60711   int result;
60712
60713   {
60714     try {
60715       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60716     } catch (std::out_of_range& e) {
60717       {
60718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60719       };
60720     } catch (std::exception& e) {
60721       {
60722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60723       };
60724     } catch (Dali::DaliException e) {
60725       {
60726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60727       };
60728     } catch (...) {
60729       {
60730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60731       };
60732     }
60733   }
60734
60735   jresult = (int)result;
60736   return jresult;
60737 }
60738
60739 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60740   int jresult ;
60741   int result;
60742
60743   {
60744     try {
60745       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60746     } catch (std::out_of_range& e) {
60747       {
60748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60749       };
60750     } catch (std::exception& e) {
60751       {
60752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60753       };
60754     } catch (...) {
60755       {
60756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60757       };
60758     }
60759   }
60760   jresult = (int)result;
60761   return jresult;
60762 }
60763
60764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60765   int jresult ;
60766   int result;
60767
60768   {
60769     try {
60770       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60771     } catch (std::out_of_range& e) {
60772       {
60773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60774       };
60775     } catch (std::exception& e) {
60776       {
60777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60778       };
60779     } catch (Dali::DaliException e) {
60780       {
60781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60782       };
60783     } catch (...) {
60784       {
60785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60786       };
60787     }
60788   }
60789
60790   jresult = (int)result;
60791   return jresult;
60792 }
60793
60794
60795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60796   int jresult ;
60797   int result;
60798
60799   {
60800     try {
60801       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60802     } catch (std::out_of_range& e) {
60803       {
60804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60805       };
60806     } catch (std::exception& e) {
60807       {
60808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60809       };
60810     } catch (Dali::DaliException e) {
60811       {
60812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60813       };
60814     } catch (...) {
60815       {
60816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60817       };
60818     }
60819   }
60820
60821   jresult = (int)result;
60822   return jresult;
60823 }
60824
60825
60826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60827   int jresult ;
60828   int result;
60829
60830   {
60831     try {
60832       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60833     } catch (std::out_of_range& e) {
60834       {
60835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60836       };
60837     } catch (std::exception& e) {
60838       {
60839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60840       };
60841     } catch (Dali::DaliException e) {
60842       {
60843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60844       };
60845     } catch (...) {
60846       {
60847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60848       };
60849     }
60850   }
60851
60852   jresult = (int)result;
60853   return jresult;
60854 }
60855
60856
60857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60858   int jresult ;
60859   int result;
60860
60861   {
60862     try {
60863       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60864     } catch (std::out_of_range& e) {
60865       {
60866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60867       };
60868     } catch (std::exception& e) {
60869       {
60870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60871       };
60872     } catch (Dali::DaliException e) {
60873       {
60874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60875       };
60876     } catch (...) {
60877       {
60878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60879       };
60880     }
60881   }
60882
60883   jresult = (int)result;
60884   return jresult;
60885 }
60886
60887
60888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60889   int jresult ;
60890   int result;
60891
60892   {
60893     try {
60894       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60895     } catch (std::out_of_range& e) {
60896       {
60897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60898       };
60899     } catch (std::exception& e) {
60900       {
60901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60902       };
60903     } catch (Dali::DaliException e) {
60904       {
60905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60906       };
60907     } catch (...) {
60908       {
60909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60910       };
60911     }
60912   }
60913
60914   jresult = (int)result;
60915   return jresult;
60916 }
60917
60918
60919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60920   int jresult ;
60921   int result;
60922
60923   {
60924     try {
60925       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60926     } catch (std::out_of_range& e) {
60927       {
60928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60929       };
60930     } catch (std::exception& e) {
60931       {
60932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60933       };
60934     } catch (Dali::DaliException e) {
60935       {
60936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60937       };
60938     } catch (...) {
60939       {
60940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60941       };
60942     }
60943   }
60944
60945   jresult = (int)result;
60946   return jresult;
60947 }
60948
60949
60950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60951   int jresult ;
60952   int result;
60953
60954   {
60955     try {
60956       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60957     } catch (std::out_of_range& e) {
60958       {
60959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60960       };
60961     } catch (std::exception& e) {
60962       {
60963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60964       };
60965     } catch (Dali::DaliException e) {
60966       {
60967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60968       };
60969     } catch (...) {
60970       {
60971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60972       };
60973     }
60974   }
60975
60976   jresult = (int)result;
60977   return jresult;
60978 }
60979
60980
60981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60982   int jresult ;
60983   int result;
60984
60985   {
60986     try {
60987       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60988     } catch (std::out_of_range& e) {
60989       {
60990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60991       };
60992     } catch (std::exception& e) {
60993       {
60994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60995       };
60996     } catch (Dali::DaliException e) {
60997       {
60998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60999       };
61000     } catch (...) {
61001       {
61002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61003       };
61004     }
61005   }
61006
61007   jresult = (int)result;
61008   return jresult;
61009 }
61010
61011
61012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
61013   int jresult ;
61014   int result;
61015
61016   {
61017     try {
61018       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
61019     } catch (std::out_of_range& e) {
61020       {
61021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61022       };
61023     } catch (std::exception& e) {
61024       {
61025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61026       };
61027     } catch (Dali::DaliException e) {
61028       {
61029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61030       };
61031     } catch (...) {
61032       {
61033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61034       };
61035     }
61036   }
61037
61038   jresult = (int)result;
61039   return jresult;
61040 }
61041
61042
61043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
61044   int jresult ;
61045   int result;
61046
61047   {
61048     try {
61049       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
61050     } catch (std::out_of_range& e) {
61051       {
61052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61053       };
61054     } catch (std::exception& e) {
61055       {
61056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61057       };
61058     } catch (Dali::DaliException e) {
61059       {
61060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61061       };
61062     } catch (...) {
61063       {
61064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61065       };
61066     }
61067   }
61068
61069   jresult = (int)result;
61070   return jresult;
61071 }
61072
61073
61074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
61075   int jresult ;
61076   int result;
61077
61078   {
61079     try {
61080       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
61081     } catch (std::out_of_range& e) {
61082       {
61083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61084       };
61085     } catch (std::exception& e) {
61086       {
61087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61088       };
61089     } catch (Dali::DaliException e) {
61090       {
61091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61092       };
61093     } catch (...) {
61094       {
61095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61096       };
61097     }
61098   }
61099
61100   jresult = (int)result;
61101   return jresult;
61102 }
61103
61104
61105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
61106   int jresult ;
61107   int result;
61108
61109   {
61110     try {
61111       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
61112     } catch (std::out_of_range& e) {
61113       {
61114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61115       };
61116     } catch (std::exception& e) {
61117       {
61118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61119       };
61120     } catch (Dali::DaliException e) {
61121       {
61122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61123       };
61124     } catch (...) {
61125       {
61126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61127       };
61128     }
61129   }
61130
61131   jresult = (int)result;
61132   return jresult;
61133 }
61134
61135
61136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
61137   int jresult ;
61138   int result;
61139
61140   {
61141     try {
61142       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
61143     } catch (std::out_of_range& e) {
61144       {
61145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61146       };
61147     } catch (std::exception& e) {
61148       {
61149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61150       };
61151     } catch (Dali::DaliException e) {
61152       {
61153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61154       };
61155     } catch (...) {
61156       {
61157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61158       };
61159     }
61160   }
61161
61162   jresult = (int)result;
61163   return jresult;
61164 }
61165
61166
61167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
61168   int jresult ;
61169   int result;
61170
61171   {
61172     try {
61173       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
61174     } catch (std::out_of_range& e) {
61175       {
61176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61177       };
61178     } catch (std::exception& e) {
61179       {
61180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61181       };
61182     } catch (Dali::DaliException e) {
61183       {
61184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61185       };
61186     } catch (...) {
61187       {
61188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61189       };
61190     }
61191   }
61192
61193   jresult = (int)result;
61194   return jresult;
61195 }
61196
61197
61198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
61199   int jresult ;
61200   int result;
61201
61202   {
61203     try {
61204       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
61205     } catch (std::out_of_range& e) {
61206       {
61207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61208       };
61209     } catch (std::exception& e) {
61210       {
61211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61212       };
61213     } catch (Dali::DaliException e) {
61214       {
61215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61216       };
61217     } catch (...) {
61218       {
61219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61220       };
61221     }
61222   }
61223
61224   jresult = (int)result;
61225   return jresult;
61226 }
61227
61228
61229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61230   int jresult ;
61231   int result;
61232
61233   {
61234     try {
61235       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61236     } catch (std::out_of_range& e) {
61237       {
61238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61239       };
61240     } catch (std::exception& e) {
61241       {
61242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61243       };
61244     } catch (Dali::DaliException e) {
61245       {
61246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61247       };
61248     } catch (...) {
61249       {
61250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61251       };
61252     }
61253   }
61254
61255   jresult = (int)result;
61256   return jresult;
61257 }
61258
61259
61260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61261   int jresult ;
61262   int result;
61263
61264   {
61265     try {
61266       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61267     } catch (std::out_of_range& e) {
61268       {
61269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61270       };
61271     } catch (std::exception& e) {
61272       {
61273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61274       };
61275     } catch (Dali::DaliException e) {
61276       {
61277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61278       };
61279     } catch (...) {
61280       {
61281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61282       };
61283     }
61284   }
61285
61286   jresult = (int)result;
61287   return jresult;
61288 }
61289
61290
61291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61292   int jresult ;
61293   int result;
61294
61295   {
61296     try {
61297       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61298     } catch (std::out_of_range& e) {
61299       {
61300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61301       };
61302     } catch (std::exception& e) {
61303       {
61304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61305       };
61306     } catch (Dali::DaliException e) {
61307       {
61308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61309       };
61310     } catch (...) {
61311       {
61312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61313       };
61314     }
61315   }
61316
61317   jresult = (int)result;
61318   return jresult;
61319 }
61320
61321
61322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61323   int jresult ;
61324   int result;
61325
61326   {
61327     try {
61328       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61329     } catch (std::out_of_range& e) {
61330       {
61331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61332       };
61333     } catch (std::exception& e) {
61334       {
61335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61336       };
61337     } catch (Dali::DaliException e) {
61338       {
61339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61340       };
61341     } catch (...) {
61342       {
61343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61344       };
61345     }
61346   }
61347
61348   jresult = (int)result;
61349   return jresult;
61350 }
61351
61352
61353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61354   int jresult ;
61355   int result;
61356
61357   {
61358     try {
61359       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61360     } catch (std::out_of_range& e) {
61361       {
61362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61363       };
61364     } catch (std::exception& e) {
61365       {
61366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61367       };
61368     } catch (Dali::DaliException e) {
61369       {
61370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61371       };
61372     } catch (...) {
61373       {
61374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61375       };
61376     }
61377   }
61378
61379   jresult = (int)result;
61380   return jresult;
61381 }
61382
61383
61384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61385   int jresult ;
61386   int result;
61387
61388   {
61389     try {
61390       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61391     } catch (std::out_of_range& e) {
61392       {
61393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61394       };
61395     } catch (std::exception& e) {
61396       {
61397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61398       };
61399     } catch (Dali::DaliException e) {
61400       {
61401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61402       };
61403     } catch (...) {
61404       {
61405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61406       };
61407     }
61408   }
61409
61410   jresult = (int)result;
61411   return jresult;
61412 }
61413
61414
61415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61416   int jresult ;
61417   int result;
61418
61419   {
61420     try {
61421       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61422     } catch (std::out_of_range& e) {
61423       {
61424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61425       };
61426     } catch (std::exception& e) {
61427       {
61428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61429       };
61430     } catch (Dali::DaliException e) {
61431       {
61432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61433       };
61434     } catch (...) {
61435       {
61436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61437       };
61438     }
61439   }
61440
61441   jresult = (int)result;
61442   return jresult;
61443 }
61444
61445
61446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61447   int jresult ;
61448   int result;
61449
61450   {
61451     try {
61452       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61453     } catch (std::out_of_range& e) {
61454       {
61455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61456       };
61457     } catch (std::exception& e) {
61458       {
61459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61460       };
61461     } catch (Dali::DaliException e) {
61462       {
61463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61464       };
61465     } catch (...) {
61466       {
61467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61468       };
61469     }
61470   }
61471
61472   jresult = (int)result;
61473   return jresult;
61474 }
61475
61476
61477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61478   int jresult ;
61479   int result;
61480
61481   {
61482     try {
61483       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61484     } catch (std::out_of_range& e) {
61485       {
61486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61487       };
61488     } catch (std::exception& e) {
61489       {
61490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61491       };
61492     } catch (Dali::DaliException e) {
61493       {
61494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61495       };
61496     } catch (...) {
61497       {
61498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61499       };
61500     }
61501   }
61502
61503   jresult = (int)result;
61504   return jresult;
61505 }
61506
61507
61508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61509   int jresult ;
61510   int result;
61511
61512   {
61513     try {
61514       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61515     } catch (std::out_of_range& e) {
61516       {
61517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61518       };
61519     } catch (std::exception& e) {
61520       {
61521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61522       };
61523     } catch (Dali::DaliException e) {
61524       {
61525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61526       };
61527     } catch (...) {
61528       {
61529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61530       };
61531     }
61532   }
61533
61534   jresult = (int)result;
61535   return jresult;
61536 }
61537
61538
61539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61540   int jresult ;
61541   int result;
61542
61543   {
61544     try {
61545       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61546     } catch (std::out_of_range& e) {
61547       {
61548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61549       };
61550     } catch (std::exception& e) {
61551       {
61552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61553       };
61554     } catch (Dali::DaliException e) {
61555       {
61556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61557       };
61558     } catch (...) {
61559       {
61560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61561       };
61562     }
61563   }
61564
61565   jresult = (int)result;
61566   return jresult;
61567 }
61568
61569
61570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61571   int jresult ;
61572   int result;
61573
61574   {
61575     try {
61576       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61577     } catch (std::out_of_range& e) {
61578       {
61579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61580       };
61581     } catch (std::exception& e) {
61582       {
61583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61584       };
61585     } catch (Dali::DaliException e) {
61586       {
61587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61588       };
61589     } catch (...) {
61590       {
61591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61592       };
61593     }
61594   }
61595
61596   jresult = (int)result;
61597   return jresult;
61598 }
61599
61600
61601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61602   int jresult ;
61603   int result;
61604
61605   {
61606     try {
61607       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61608     } catch (std::out_of_range& e) {
61609       {
61610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61611       };
61612     } catch (std::exception& e) {
61613       {
61614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61615       };
61616     } catch (Dali::DaliException e) {
61617       {
61618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61619       };
61620     } catch (...) {
61621       {
61622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61623       };
61624     }
61625   }
61626
61627   jresult = (int)result;
61628   return jresult;
61629 }
61630
61631
61632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61633   void * jresult ;
61634   Dali::Toolkit::Builder *result = 0 ;
61635
61636   {
61637     try {
61638       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61639     } catch (std::out_of_range& e) {
61640       {
61641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61642       };
61643     } catch (std::exception& e) {
61644       {
61645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61646       };
61647     } catch (Dali::DaliException e) {
61648       {
61649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61650       };
61651     } catch (...) {
61652       {
61653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61654       };
61655     }
61656   }
61657
61658   jresult = (void *)result;
61659   return jresult;
61660 }
61661
61662
61663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61664   void * jresult ;
61665   Dali::Toolkit::Builder result;
61666
61667   {
61668     try {
61669       result = Dali::Toolkit::Builder::New();
61670     } catch (std::out_of_range& e) {
61671       {
61672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61673       };
61674     } catch (std::exception& e) {
61675       {
61676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61677       };
61678     } catch (Dali::DaliException e) {
61679       {
61680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61681       };
61682     } catch (...) {
61683       {
61684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61685       };
61686     }
61687   }
61688
61689   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61690   return jresult;
61691 }
61692
61693
61694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61695   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61696
61697   arg1 = (Dali::Toolkit::Builder *)jarg1;
61698   {
61699     try {
61700       delete arg1;
61701     } catch (std::out_of_range& e) {
61702       {
61703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61704       };
61705     } catch (std::exception& e) {
61706       {
61707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61708       };
61709     } catch (Dali::DaliException e) {
61710       {
61711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61712       };
61713     } catch (...) {
61714       {
61715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61716       };
61717     }
61718   }
61719
61720 }
61721
61722
61723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61724   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61725   std::string *arg2 = 0 ;
61726   Dali::Toolkit::Builder::UIFormat arg3 ;
61727
61728   arg1 = (Dali::Toolkit::Builder *)jarg1;
61729   if (!jarg2) {
61730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61731     return ;
61732   }
61733   std::string arg2_str(jarg2);
61734   arg2 = &arg2_str;
61735   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61736   {
61737     try {
61738       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61739     } catch (std::out_of_range& e) {
61740       {
61741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61742       };
61743     } catch (std::exception& e) {
61744       {
61745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61746       };
61747     } catch (Dali::DaliException e) {
61748       {
61749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61750       };
61751     } catch (...) {
61752       {
61753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61754       };
61755     }
61756   }
61757
61758
61759   //argout typemap for const std::string&
61760
61761 }
61762
61763
61764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61765   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61766   std::string *arg2 = 0 ;
61767
61768   arg1 = (Dali::Toolkit::Builder *)jarg1;
61769   if (!jarg2) {
61770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61771     return ;
61772   }
61773   std::string arg2_str(jarg2);
61774   arg2 = &arg2_str;
61775   {
61776     try {
61777       (arg1)->LoadFromString((std::string const &)*arg2);
61778     } catch (std::out_of_range& e) {
61779       {
61780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61781       };
61782     } catch (std::exception& e) {
61783       {
61784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61785       };
61786     } catch (Dali::DaliException e) {
61787       {
61788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61789       };
61790     } catch (...) {
61791       {
61792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61793       };
61794     }
61795   }
61796
61797
61798   //argout typemap for const std::string&
61799
61800 }
61801
61802
61803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61804   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61805   Dali::Property::Map *arg2 = 0 ;
61806
61807   arg1 = (Dali::Toolkit::Builder *)jarg1;
61808   arg2 = (Dali::Property::Map *)jarg2;
61809   if (!arg2) {
61810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61811     return ;
61812   }
61813   {
61814     try {
61815       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61816     } catch (std::out_of_range& e) {
61817       {
61818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61819       };
61820     } catch (std::exception& e) {
61821       {
61822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61823       };
61824     } catch (Dali::DaliException e) {
61825       {
61826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61827       };
61828     } catch (...) {
61829       {
61830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61831       };
61832     }
61833   }
61834
61835 }
61836
61837
61838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61839   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61840   std::string *arg2 = 0 ;
61841   Dali::Property::Value *arg3 = 0 ;
61842
61843   arg1 = (Dali::Toolkit::Builder *)jarg1;
61844   if (!jarg2) {
61845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61846     return ;
61847   }
61848   std::string arg2_str(jarg2);
61849   arg2 = &arg2_str;
61850   arg3 = (Dali::Property::Value *)jarg3;
61851   if (!arg3) {
61852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61853     return ;
61854   }
61855   {
61856     try {
61857       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61858     } catch (std::out_of_range& e) {
61859       {
61860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61861       };
61862     } catch (std::exception& e) {
61863       {
61864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61865       };
61866     } catch (Dali::DaliException e) {
61867       {
61868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61869       };
61870     } catch (...) {
61871       {
61872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61873       };
61874     }
61875   }
61876
61877
61878   //argout typemap for const std::string&
61879
61880 }
61881
61882
61883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61884   void * jresult ;
61885   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61886   Dali::Property::Map *result = 0 ;
61887
61888   arg1 = (Dali::Toolkit::Builder *)jarg1;
61889   {
61890     try {
61891       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61892     } catch (std::out_of_range& e) {
61893       {
61894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61895       };
61896     } catch (std::exception& e) {
61897       {
61898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61899       };
61900     } catch (Dali::DaliException e) {
61901       {
61902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61903       };
61904     } catch (...) {
61905       {
61906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61907       };
61908     }
61909   }
61910
61911   jresult = (void *)result;
61912   return jresult;
61913 }
61914
61915
61916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61917   void * jresult ;
61918   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61919   std::string *arg2 = 0 ;
61920   Dali::Property::Value *result = 0 ;
61921
61922   arg1 = (Dali::Toolkit::Builder *)jarg1;
61923   if (!jarg2) {
61924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61925     return 0;
61926   }
61927   std::string arg2_str(jarg2);
61928   arg2 = &arg2_str;
61929   {
61930     try {
61931       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61932     } catch (std::out_of_range& e) {
61933       {
61934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61935       };
61936     } catch (std::exception& e) {
61937       {
61938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61939       };
61940     } catch (Dali::DaliException e) {
61941       {
61942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61943       };
61944     } catch (...) {
61945       {
61946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61947       };
61948     }
61949   }
61950
61951   jresult = (void *)result;
61952
61953   //argout typemap for const std::string&
61954
61955   return jresult;
61956 }
61957
61958
61959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61960   void * jresult ;
61961   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61962   std::string *arg2 = 0 ;
61963   Dali::Animation result;
61964
61965   arg1 = (Dali::Toolkit::Builder *)jarg1;
61966   if (!jarg2) {
61967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61968     return 0;
61969   }
61970   std::string arg2_str(jarg2);
61971   arg2 = &arg2_str;
61972   {
61973     try {
61974       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61975     } catch (std::out_of_range& e) {
61976       {
61977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61978       };
61979     } catch (std::exception& e) {
61980       {
61981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61982       };
61983     } catch (Dali::DaliException e) {
61984       {
61985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61986       };
61987     } catch (...) {
61988       {
61989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61990       };
61991     }
61992   }
61993
61994   jresult = new Dali::Animation((const Dali::Animation &)result);
61995
61996   //argout typemap for const std::string&
61997
61998   return jresult;
61999 }
62000
62001
62002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62003   void * jresult ;
62004   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62005   std::string *arg2 = 0 ;
62006   Dali::Property::Map *arg3 = 0 ;
62007   Dali::Animation result;
62008
62009   arg1 = (Dali::Toolkit::Builder *)jarg1;
62010   if (!jarg2) {
62011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62012     return 0;
62013   }
62014   std::string arg2_str(jarg2);
62015   arg2 = &arg2_str;
62016   arg3 = (Dali::Property::Map *)jarg3;
62017   if (!arg3) {
62018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62019     return 0;
62020   }
62021   {
62022     try {
62023       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62024     } catch (std::out_of_range& e) {
62025       {
62026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62027       };
62028     } catch (std::exception& e) {
62029       {
62030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62031       };
62032     } catch (Dali::DaliException e) {
62033       {
62034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62035       };
62036     } catch (...) {
62037       {
62038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62039       };
62040     }
62041   }
62042
62043   jresult = new Dali::Animation((const Dali::Animation &)result);
62044
62045   //argout typemap for const std::string&
62046
62047   return jresult;
62048 }
62049
62050
62051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62052   void * jresult ;
62053   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62054   std::string *arg2 = 0 ;
62055   Dali::Actor arg3 ;
62056   Dali::Actor *argp3 ;
62057   Dali::Animation result;
62058
62059   arg1 = (Dali::Toolkit::Builder *)jarg1;
62060   if (!jarg2) {
62061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62062     return 0;
62063   }
62064   std::string arg2_str(jarg2);
62065   arg2 = &arg2_str;
62066   argp3 = (Dali::Actor *)jarg3;
62067   if (!argp3) {
62068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62069     return 0;
62070   }
62071   arg3 = *argp3;
62072   {
62073     try {
62074       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
62075     } catch (std::out_of_range& e) {
62076       {
62077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62078       };
62079     } catch (std::exception& e) {
62080       {
62081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62082       };
62083     } catch (Dali::DaliException e) {
62084       {
62085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62086       };
62087     } catch (...) {
62088       {
62089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62090       };
62091     }
62092   }
62093
62094   jresult = new Dali::Animation((const Dali::Animation &)result);
62095
62096   //argout typemap for const std::string&
62097
62098   return jresult;
62099 }
62100
62101
62102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
62103   void * jresult ;
62104   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62105   std::string *arg2 = 0 ;
62106   Dali::Property::Map *arg3 = 0 ;
62107   Dali::Actor arg4 ;
62108   Dali::Actor *argp4 ;
62109   Dali::Animation result;
62110
62111   arg1 = (Dali::Toolkit::Builder *)jarg1;
62112   if (!jarg2) {
62113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62114     return 0;
62115   }
62116   std::string arg2_str(jarg2);
62117   arg2 = &arg2_str;
62118   arg3 = (Dali::Property::Map *)jarg3;
62119   if (!arg3) {
62120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62121     return 0;
62122   }
62123   argp4 = (Dali::Actor *)jarg4;
62124   if (!argp4) {
62125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62126     return 0;
62127   }
62128   arg4 = *argp4;
62129   {
62130     try {
62131       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
62132     } catch (std::out_of_range& e) {
62133       {
62134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62135       };
62136     } catch (std::exception& e) {
62137       {
62138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62139       };
62140     } catch (Dali::DaliException e) {
62141       {
62142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62143       };
62144     } catch (...) {
62145       {
62146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62147       };
62148     }
62149   }
62150
62151   jresult = new Dali::Animation((const Dali::Animation &)result);
62152
62153   //argout typemap for const std::string&
62154
62155   return jresult;
62156 }
62157
62158
62159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
62160   void * jresult ;
62161   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62162   std::string *arg2 = 0 ;
62163   Dali::BaseHandle result;
62164
62165   arg1 = (Dali::Toolkit::Builder *)jarg1;
62166   if (!jarg2) {
62167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62168     return 0;
62169   }
62170   std::string arg2_str(jarg2);
62171   arg2 = &arg2_str;
62172   {
62173     try {
62174       result = (arg1)->Create((std::string const &)*arg2);
62175     } catch (std::out_of_range& e) {
62176       {
62177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62178       };
62179     } catch (std::exception& e) {
62180       {
62181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62182       };
62183     } catch (Dali::DaliException e) {
62184       {
62185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62186       };
62187     } catch (...) {
62188       {
62189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62190       };
62191     }
62192   }
62193
62194   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62195
62196   //argout typemap for const std::string&
62197
62198   return jresult;
62199 }
62200
62201
62202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62203   void * jresult ;
62204   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62205   std::string *arg2 = 0 ;
62206   Dali::Property::Map *arg3 = 0 ;
62207   Dali::BaseHandle result;
62208
62209   arg1 = (Dali::Toolkit::Builder *)jarg1;
62210   if (!jarg2) {
62211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62212     return 0;
62213   }
62214   std::string arg2_str(jarg2);
62215   arg2 = &arg2_str;
62216   arg3 = (Dali::Property::Map *)jarg3;
62217   if (!arg3) {
62218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62219     return 0;
62220   }
62221   {
62222     try {
62223       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62224     } catch (std::out_of_range& e) {
62225       {
62226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62227       };
62228     } catch (std::exception& e) {
62229       {
62230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62231       };
62232     } catch (Dali::DaliException e) {
62233       {
62234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62235       };
62236     } catch (...) {
62237       {
62238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62239       };
62240     }
62241   }
62242
62243   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62244
62245   //argout typemap for const std::string&
62246
62247   return jresult;
62248 }
62249
62250
62251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62252   void * jresult ;
62253   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62254   std::string *arg2 = 0 ;
62255   Dali::BaseHandle result;
62256
62257   arg1 = (Dali::Toolkit::Builder *)jarg1;
62258   if (!jarg2) {
62259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62260     return 0;
62261   }
62262   std::string arg2_str(jarg2);
62263   arg2 = &arg2_str;
62264   {
62265     try {
62266       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62267     } catch (std::out_of_range& e) {
62268       {
62269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62270       };
62271     } catch (std::exception& e) {
62272       {
62273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62274       };
62275     } catch (Dali::DaliException e) {
62276       {
62277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62278       };
62279     } catch (...) {
62280       {
62281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62282       };
62283     }
62284   }
62285
62286   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62287
62288   //argout typemap for const std::string&
62289
62290   return jresult;
62291 }
62292
62293
62294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62295   unsigned int jresult ;
62296   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62297   std::string *arg2 = 0 ;
62298   Dali::Handle *arg3 = 0 ;
62299   bool result;
62300
62301   arg1 = (Dali::Toolkit::Builder *)jarg1;
62302   if (!jarg2) {
62303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62304     return 0;
62305   }
62306   std::string arg2_str(jarg2);
62307   arg2 = &arg2_str;
62308   arg3 = (Dali::Handle *)jarg3;
62309   if (!arg3) {
62310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62311     return 0;
62312   }
62313   {
62314     try {
62315       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
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 = result;
62336
62337   //argout typemap for const std::string&
62338
62339   return jresult;
62340 }
62341
62342
62343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62344   unsigned int jresult ;
62345   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62346   Dali::Handle *arg2 = 0 ;
62347   std::string *arg3 = 0 ;
62348   bool result;
62349
62350   arg1 = (Dali::Toolkit::Builder *)jarg1;
62351   arg2 = (Dali::Handle *)jarg2;
62352   if (!arg2) {
62353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62354     return 0;
62355   }
62356   if (!jarg3) {
62357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62358     return 0;
62359   }
62360   std::string arg3_str(jarg3);
62361   arg3 = &arg3_str;
62362   {
62363     try {
62364       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62365     } catch (std::out_of_range& e) {
62366       {
62367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62368       };
62369     } catch (std::exception& e) {
62370       {
62371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62372       };
62373     } catch (Dali::DaliException e) {
62374       {
62375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62376       };
62377     } catch (...) {
62378       {
62379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62380       };
62381     }
62382   }
62383
62384   jresult = result;
62385
62386   //argout typemap for const std::string&
62387
62388   return jresult;
62389 }
62390
62391
62392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62393   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62394   Dali::Actor arg2 ;
62395   Dali::Actor *argp2 ;
62396
62397   arg1 = (Dali::Toolkit::Builder *)jarg1;
62398   argp2 = (Dali::Actor *)jarg2;
62399   if (!argp2) {
62400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62401     return ;
62402   }
62403   arg2 = *argp2;
62404   {
62405     try {
62406       (arg1)->AddActors(arg2);
62407     } catch (std::out_of_range& e) {
62408       {
62409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62410       };
62411     } catch (std::exception& e) {
62412       {
62413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62414       };
62415     } catch (Dali::DaliException e) {
62416       {
62417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62418       };
62419     } catch (...) {
62420       {
62421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62422       };
62423     }
62424   }
62425
62426 }
62427
62428
62429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62430   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62431   std::string *arg2 = 0 ;
62432   Dali::Actor arg3 ;
62433   Dali::Actor *argp3 ;
62434
62435   arg1 = (Dali::Toolkit::Builder *)jarg1;
62436   if (!jarg2) {
62437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62438     return ;
62439   }
62440   std::string arg2_str(jarg2);
62441   arg2 = &arg2_str;
62442   argp3 = (Dali::Actor *)jarg3;
62443   if (!argp3) {
62444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62445     return ;
62446   }
62447   arg3 = *argp3;
62448   {
62449     try {
62450       (arg1)->AddActors((std::string const &)*arg2,arg3);
62451     } catch (std::out_of_range& e) {
62452       {
62453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62454       };
62455     } catch (std::exception& e) {
62456       {
62457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62458       };
62459     } catch (Dali::DaliException e) {
62460       {
62461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62462       };
62463     } catch (...) {
62464       {
62465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62466       };
62467     }
62468   }
62469
62470
62471   //argout typemap for const std::string&
62472
62473 }
62474
62475
62476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62477   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62478   std::string *arg2 = 0 ;
62479
62480   arg1 = (Dali::Toolkit::Builder *)jarg1;
62481   if (!jarg2) {
62482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62483     return ;
62484   }
62485   std::string arg2_str(jarg2);
62486   arg2 = &arg2_str;
62487   {
62488     try {
62489       (arg1)->CreateRenderTask((std::string const &)*arg2);
62490     } catch (std::out_of_range& e) {
62491       {
62492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62493       };
62494     } catch (std::exception& e) {
62495       {
62496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62497       };
62498     } catch (Dali::DaliException e) {
62499       {
62500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62501       };
62502     } catch (...) {
62503       {
62504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62505       };
62506     }
62507   }
62508
62509
62510   //argout typemap for const std::string&
62511
62512 }
62513
62514
62515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62516   void * jresult ;
62517   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62518   std::string *arg2 = 0 ;
62519   Dali::FrameBufferImage result;
62520
62521   arg1 = (Dali::Toolkit::Builder *)jarg1;
62522   if (!jarg2) {
62523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62524     return 0;
62525   }
62526   std::string arg2_str(jarg2);
62527   arg2 = &arg2_str;
62528   {
62529     try {
62530       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62531     } catch (std::out_of_range& e) {
62532       {
62533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62534       };
62535     } catch (std::exception& e) {
62536       {
62537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62538       };
62539     } catch (Dali::DaliException e) {
62540       {
62541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62542       };
62543     } catch (...) {
62544       {
62545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62546       };
62547     }
62548   }
62549
62550   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62551
62552   //argout typemap for const std::string&
62553
62554   return jresult;
62555 }
62556
62557
62558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62559   void * jresult ;
62560   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62561   std::string *arg2 = 0 ;
62562   Dali::Path result;
62563
62564   arg1 = (Dali::Toolkit::Builder *)jarg1;
62565   if (!jarg2) {
62566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62567     return 0;
62568   }
62569   std::string arg2_str(jarg2);
62570   arg2 = &arg2_str;
62571   {
62572     try {
62573       result = (arg1)->GetPath((std::string const &)*arg2);
62574     } catch (std::out_of_range& e) {
62575       {
62576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62577       };
62578     } catch (std::exception& e) {
62579       {
62580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62581       };
62582     } catch (Dali::DaliException e) {
62583       {
62584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62585       };
62586     } catch (...) {
62587       {
62588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62589       };
62590     }
62591   }
62592
62593   jresult = new Dali::Path((const Dali::Path &)result);
62594
62595   //argout typemap for const std::string&
62596
62597   return jresult;
62598 }
62599
62600
62601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62602   void * jresult ;
62603   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62604   std::string *arg2 = 0 ;
62605   Dali::PathConstrainer result;
62606
62607   arg1 = (Dali::Toolkit::Builder *)jarg1;
62608   if (!jarg2) {
62609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62610     return 0;
62611   }
62612   std::string arg2_str(jarg2);
62613   arg2 = &arg2_str;
62614   {
62615     try {
62616       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62617     } catch (std::out_of_range& e) {
62618       {
62619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62620       };
62621     } catch (std::exception& e) {
62622       {
62623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62624       };
62625     } catch (Dali::DaliException e) {
62626       {
62627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62628       };
62629     } catch (...) {
62630       {
62631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62632       };
62633     }
62634   }
62635
62636   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62637
62638   //argout typemap for const std::string&
62639
62640   return jresult;
62641 }
62642
62643
62644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62645   void * jresult ;
62646   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62647   std::string *arg2 = 0 ;
62648   Dali::LinearConstrainer result;
62649
62650   arg1 = (Dali::Toolkit::Builder *)jarg1;
62651   if (!jarg2) {
62652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62653     return 0;
62654   }
62655   std::string arg2_str(jarg2);
62656   arg2 = &arg2_str;
62657   {
62658     try {
62659       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62660     } catch (std::out_of_range& e) {
62661       {
62662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62663       };
62664     } catch (std::exception& e) {
62665       {
62666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62667       };
62668     } catch (Dali::DaliException e) {
62669       {
62670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62671       };
62672     } catch (...) {
62673       {
62674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62675       };
62676     }
62677   }
62678
62679   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62680
62681   //argout typemap for const std::string&
62682
62683   return jresult;
62684 }
62685
62686
62687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62688   void * jresult ;
62689   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62690   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62691
62692   arg1 = (Dali::Toolkit::Builder *)jarg1;
62693   {
62694     try {
62695       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62696     } catch (std::out_of_range& e) {
62697       {
62698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62699       };
62700     } catch (std::exception& e) {
62701       {
62702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62703       };
62704     } catch (Dali::DaliException e) {
62705       {
62706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62707       };
62708     } catch (...) {
62709       {
62710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62711       };
62712     }
62713   }
62714
62715   jresult = (void *)result;
62716   return jresult;
62717 }
62718
62719
62720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62721   void * jresult ;
62722   Dali::Toolkit::TransitionData *result = 0 ;
62723
62724   {
62725     try {
62726       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62727     } catch (std::out_of_range& e) {
62728       {
62729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62730       };
62731     } catch (std::exception& e) {
62732       {
62733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62734       };
62735     } catch (Dali::DaliException e) {
62736       {
62737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62738       };
62739     } catch (...) {
62740       {
62741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62742       };
62743     }
62744   }
62745
62746   jresult = (void *)result;
62747   return jresult;
62748 }
62749
62750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62751   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62752
62753   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62754   {
62755     try {
62756       delete arg1;
62757     } catch (std::out_of_range& e) {
62758       {
62759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62760       };
62761     } catch (std::exception& e) {
62762       {
62763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62764       };
62765     } catch (Dali::DaliException e) {
62766       {
62767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62768       };
62769     } catch (...) {
62770       {
62771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62772       };
62773     }
62774   }
62775
62776 }
62777
62778
62779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62780   void * jresult ;
62781   Dali::Property::Map *arg1 = 0 ;
62782   Dali::Toolkit::TransitionData result;
62783
62784   arg1 = (Dali::Property::Map *)jarg1;
62785   if (!arg1) {
62786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62787     return 0;
62788   }
62789   {
62790     try {
62791       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62792     } catch (std::out_of_range& e) {
62793       {
62794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62795       };
62796     } catch (std::exception& e) {
62797       {
62798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62799       };
62800     } catch (Dali::DaliException e) {
62801       {
62802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62803       };
62804     } catch (...) {
62805       {
62806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62807       };
62808     }
62809   }
62810
62811   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62812   return jresult;
62813 }
62814
62815
62816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62817   void * jresult ;
62818   Dali::Property::Array *arg1 = 0 ;
62819   Dali::Toolkit::TransitionData result;
62820
62821   arg1 = (Dali::Property::Array *)jarg1;
62822   if (!arg1) {
62823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62824     return 0;
62825   }
62826   {
62827     try {
62828       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62829     } catch (std::out_of_range& e) {
62830       {
62831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62832       };
62833     } catch (std::exception& e) {
62834       {
62835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62836       };
62837     } catch (Dali::DaliException e) {
62838       {
62839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62840       };
62841     } catch (...) {
62842       {
62843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62844       };
62845     }
62846   }
62847
62848   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62849   return jresult;
62850 }
62851
62852
62853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62854   void * jresult ;
62855   Dali::BaseHandle arg1 ;
62856   Dali::BaseHandle *argp1 ;
62857   Dali::Toolkit::TransitionData result;
62858
62859   argp1 = (Dali::BaseHandle *)jarg1;
62860   if (!argp1) {
62861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62862     return 0;
62863   }
62864   arg1 = *argp1;
62865   {
62866     try {
62867       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62868     } catch (std::out_of_range& e) {
62869       {
62870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62871       };
62872     } catch (std::exception& e) {
62873       {
62874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62875       };
62876     } catch (Dali::DaliException e) {
62877       {
62878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62879       };
62880     } catch (...) {
62881       {
62882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62883       };
62884     }
62885   }
62886
62887   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62888   return jresult;
62889 }
62890
62891
62892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62893   void * jresult ;
62894   Dali::Toolkit::TransitionData *arg1 = 0 ;
62895   Dali::Toolkit::TransitionData *result = 0 ;
62896
62897   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62898   if (!arg1) {
62899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62900     return 0;
62901   }
62902   {
62903     try {
62904       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62905     } catch (std::out_of_range& e) {
62906       {
62907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62908       };
62909     } catch (std::exception& e) {
62910       {
62911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62912       };
62913     } catch (Dali::DaliException e) {
62914       {
62915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62916       };
62917     } catch (...) {
62918       {
62919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62920       };
62921     }
62922   }
62923
62924   jresult = (void *)result;
62925   return jresult;
62926 }
62927
62928
62929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62930   void * jresult ;
62931   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62932   Dali::Toolkit::TransitionData *arg2 = 0 ;
62933   Dali::Toolkit::TransitionData *result = 0 ;
62934
62935   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62936   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62937   if (!arg2) {
62938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62939     return 0;
62940   }
62941   {
62942     try {
62943       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62944     } catch (std::out_of_range& e) {
62945       {
62946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62947       };
62948     } catch (std::exception& e) {
62949       {
62950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62951       };
62952     } catch (Dali::DaliException e) {
62953       {
62954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62955       };
62956     } catch (...) {
62957       {
62958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62959       };
62960     }
62961   }
62962
62963   jresult = (void *)result;
62964   return jresult;
62965 }
62966
62967
62968 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62969   unsigned long jresult ;
62970   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62971   size_t result;
62972
62973   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62974   {
62975     try {
62976       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62977     } catch (std::out_of_range& e) {
62978       {
62979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62980       };
62981     } catch (std::exception& e) {
62982       {
62983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62984       };
62985     } catch (Dali::DaliException e) {
62986       {
62987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62988       };
62989     } catch (...) {
62990       {
62991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62992       };
62993     }
62994   }
62995
62996   jresult = (unsigned long)result;
62997   return jresult;
62998 }
62999
63000
63001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
63002   void * jresult ;
63003   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
63004   size_t arg2 ;
63005   Dali::Property::Map result;
63006
63007   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
63008   arg2 = (size_t)jarg2;
63009   {
63010     try {
63011       result = (arg1)->GetAnimatorAt(arg2);
63012     } catch (std::out_of_range& e) {
63013       {
63014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63015       };
63016     } catch (std::exception& e) {
63017       {
63018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63019       };
63020     } catch (Dali::DaliException e) {
63021       {
63022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63023       };
63024     } catch (...) {
63025       {
63026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63027       };
63028     }
63029   }
63030
63031   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
63032   return jresult;
63033 }
63034
63035
63036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
63037   int jresult ;
63038   int result;
63039
63040   {
63041     try {
63042       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
63043     } catch (std::out_of_range& e) {
63044       {
63045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63046       };
63047     } catch (std::exception& e) {
63048       {
63049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63050       };
63051     } catch (Dali::DaliException e) {
63052       {
63053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63054       };
63055     } catch (...) {
63056       {
63057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63058       };
63059     }
63060   }
63061
63062   jresult = (int)result;
63063   return jresult;
63064 }
63065
63066
63067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
63068   int jresult ;
63069   int result;
63070
63071   {
63072     try {
63073       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
63074     } catch (std::out_of_range& e) {
63075       {
63076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63077       };
63078     } catch (std::exception& e) {
63079       {
63080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63081       };
63082     } catch (Dali::DaliException e) {
63083       {
63084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63085       };
63086     } catch (...) {
63087       {
63088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63089       };
63090     }
63091   }
63092
63093   jresult = (int)result;
63094   return jresult;
63095 }
63096
63097
63098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
63099   int jresult ;
63100   int result;
63101
63102   {
63103     try {
63104       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
63105     } catch (std::out_of_range& e) {
63106       {
63107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63108       };
63109     } catch (std::exception& e) {
63110       {
63111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63112       };
63113     } catch (Dali::DaliException e) {
63114       {
63115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63116       };
63117     } catch (...) {
63118       {
63119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63120       };
63121     }
63122   }
63123
63124   jresult = (int)result;
63125   return jresult;
63126 }
63127
63128
63129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
63130   int jresult ;
63131   int result;
63132
63133   {
63134     try {
63135       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
63136     } catch (std::out_of_range& e) {
63137       {
63138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63139       };
63140     } catch (std::exception& e) {
63141       {
63142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63143       };
63144     } catch (Dali::DaliException e) {
63145       {
63146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63147       };
63148     } catch (...) {
63149       {
63150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63151       };
63152     }
63153   }
63154
63155   jresult = (int)result;
63156   return jresult;
63157 }
63158
63159
63160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
63161   int jresult ;
63162   int result;
63163
63164   {
63165     try {
63166       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
63167     } catch (std::out_of_range& e) {
63168       {
63169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63170       };
63171     } catch (std::exception& e) {
63172       {
63173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63174       };
63175     } catch (Dali::DaliException e) {
63176       {
63177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63178       };
63179     } catch (...) {
63180       {
63181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63182       };
63183     }
63184   }
63185
63186   jresult = (int)result;
63187   return jresult;
63188 }
63189
63190
63191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63192   int jresult ;
63193   int result;
63194
63195   {
63196     try {
63197       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63198     } catch (std::out_of_range& e) {
63199       {
63200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63201       };
63202     } catch (std::exception& e) {
63203       {
63204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63205       };
63206     } catch (Dali::DaliException e) {
63207       {
63208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63209       };
63210     } catch (...) {
63211       {
63212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63213       };
63214     }
63215   }
63216
63217   jresult = (int)result;
63218   return jresult;
63219 }
63220
63221
63222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63223   int jresult ;
63224   int result;
63225
63226   {
63227     try {
63228       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63229     } catch (std::out_of_range& e) {
63230       {
63231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63232       };
63233     } catch (std::exception& e) {
63234       {
63235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63236       };
63237     } catch (Dali::DaliException e) {
63238       {
63239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63240       };
63241     } catch (...) {
63242       {
63243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63244       };
63245     }
63246   }
63247
63248   jresult = (int)result;
63249   return jresult;
63250 }
63251
63252
63253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63254   int jresult ;
63255   int result;
63256
63257   {
63258     try {
63259       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63260     } catch (std::out_of_range& e) {
63261       {
63262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63263       };
63264     } catch (std::exception& e) {
63265       {
63266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63267       };
63268     } catch (Dali::DaliException e) {
63269       {
63270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63271       };
63272     } catch (...) {
63273       {
63274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63275       };
63276     }
63277   }
63278
63279   jresult = (int)result;
63280   return jresult;
63281 }
63282
63283
63284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63285   int jresult ;
63286   int result;
63287
63288   {
63289     try {
63290       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63291     } catch (std::out_of_range& e) {
63292       {
63293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63294       };
63295     } catch (std::exception& e) {
63296       {
63297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63298       };
63299     } catch (Dali::DaliException e) {
63300       {
63301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63302       };
63303     } catch (...) {
63304       {
63305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63306       };
63307     }
63308   }
63309
63310   jresult = (int)result;
63311   return jresult;
63312 }
63313
63314
63315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63316   int jresult ;
63317   int result;
63318
63319   {
63320     try {
63321       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63322     } catch (std::out_of_range& e) {
63323       {
63324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63325       };
63326     } catch (std::exception& e) {
63327       {
63328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63329       };
63330     } catch (Dali::DaliException e) {
63331       {
63332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63333       };
63334     } catch (...) {
63335       {
63336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63337       };
63338     }
63339   }
63340
63341   jresult = (int)result;
63342   return jresult;
63343 }
63344
63345
63346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63347   int jresult ;
63348   int result;
63349
63350   {
63351     try {
63352       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63353     } catch (std::out_of_range& e) {
63354       {
63355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63356       };
63357     } catch (std::exception& e) {
63358       {
63359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63360       };
63361     } catch (Dali::DaliException e) {
63362       {
63363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63364       };
63365     } catch (...) {
63366       {
63367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63368       };
63369     }
63370   }
63371
63372   jresult = (int)result;
63373   return jresult;
63374 }
63375
63376
63377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63378   int jresult ;
63379   int result;
63380
63381   {
63382     try {
63383       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63384     } catch (std::out_of_range& e) {
63385       {
63386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63387       };
63388     } catch (std::exception& e) {
63389       {
63390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63391       };
63392     } catch (Dali::DaliException e) {
63393       {
63394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63395       };
63396     } catch (...) {
63397       {
63398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63399       };
63400     }
63401   }
63402
63403   jresult = (int)result;
63404   return jresult;
63405 }
63406
63407
63408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63409   int jresult ;
63410   int result;
63411
63412   {
63413     try {
63414       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63415     } catch (std::out_of_range& e) {
63416       {
63417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63418       };
63419     } catch (std::exception& e) {
63420       {
63421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63422       };
63423     } catch (Dali::DaliException e) {
63424       {
63425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63426       };
63427     } catch (...) {
63428       {
63429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63430       };
63431     }
63432   }
63433
63434   jresult = (int)result;
63435   return jresult;
63436 }
63437
63438
63439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63440   int jresult ;
63441   int result;
63442
63443   {
63444     try {
63445       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63446     } catch (std::out_of_range& e) {
63447       {
63448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63449       };
63450     } catch (std::exception& e) {
63451       {
63452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63453       };
63454     } catch (Dali::DaliException e) {
63455       {
63456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63457       };
63458     } catch (...) {
63459       {
63460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63461       };
63462     }
63463   }
63464
63465   jresult = (int)result;
63466   return jresult;
63467 }
63468
63469
63470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63471   void * jresult ;
63472   Dali::Toolkit::Control result;
63473
63474   {
63475     try {
63476       result = Dali::Toolkit::Internal::Control::New();
63477     } catch (std::out_of_range& e) {
63478       {
63479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63480       };
63481     } catch (std::exception& e) {
63482       {
63483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63484       };
63485     } catch (Dali::DaliException e) {
63486       {
63487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63488       };
63489     } catch (...) {
63490       {
63491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63492       };
63493     }
63494   }
63495
63496   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63497   return jresult;
63498 }
63499
63500
63501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63503   std::string *arg2 = 0 ;
63504
63505   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63506   if (!jarg2) {
63507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63508     return ;
63509   }
63510   std::string arg2_str(jarg2);
63511   arg2 = &arg2_str;
63512   {
63513     try {
63514       (arg1)->SetStyleName((std::string const &)*arg2);
63515     } catch (std::out_of_range& e) {
63516       {
63517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63518       };
63519     } catch (std::exception& e) {
63520       {
63521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63522       };
63523     } catch (Dali::DaliException e) {
63524       {
63525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63526       };
63527     } catch (...) {
63528       {
63529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63530       };
63531     }
63532   }
63533
63534
63535   //argout typemap for const std::string&
63536
63537 }
63538
63539
63540 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63541   char * jresult ;
63542   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63543   std::string *result = 0 ;
63544
63545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63546   {
63547     try {
63548       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63549     } catch (std::out_of_range& e) {
63550       {
63551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63552       };
63553     } catch (std::exception& e) {
63554       {
63555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63556       };
63557     } catch (Dali::DaliException e) {
63558       {
63559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63560       };
63561     } catch (...) {
63562       {
63563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63564       };
63565     }
63566   }
63567
63568   jresult = SWIG_csharp_string_callback(result->c_str());
63569   return jresult;
63570 }
63571
63572
63573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63574   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63575   Dali::Vector4 *arg2 = 0 ;
63576
63577   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63578   arg2 = (Dali::Vector4 *)jarg2;
63579   if (!arg2) {
63580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63581     return ;
63582   }
63583   {
63584     try {
63585       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63586     } catch (std::out_of_range& e) {
63587       {
63588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63589       };
63590     } catch (std::exception& e) {
63591       {
63592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63593       };
63594     } catch (Dali::DaliException e) {
63595       {
63596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63597       };
63598     } catch (...) {
63599       {
63600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63601       };
63602     }
63603   }
63604
63605 }
63606
63607
63608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63609   void * jresult ;
63610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63611   Dali::Vector4 result;
63612
63613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63614   {
63615     try {
63616       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63617     } catch (std::out_of_range& e) {
63618       {
63619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63620       };
63621     } catch (std::exception& e) {
63622       {
63623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63624       };
63625     } catch (Dali::DaliException e) {
63626       {
63627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63628       };
63629     } catch (...) {
63630       {
63631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63632       };
63633     }
63634   }
63635
63636   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63637   return jresult;
63638 }
63639
63640
63641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63642   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63643   Dali::Image arg2 ;
63644   Dali::Image *argp2 ;
63645
63646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63647   argp2 = (Dali::Image *)jarg2;
63648   if (!argp2) {
63649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63650     return ;
63651   }
63652   arg2 = *argp2;
63653   {
63654     try {
63655       (arg1)->SetBackgroundImage(arg2);
63656     } catch (std::out_of_range& e) {
63657       {
63658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63659       };
63660     } catch (std::exception& e) {
63661       {
63662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63663       };
63664     } catch (Dali::DaliException e) {
63665       {
63666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63667       };
63668     } catch (...) {
63669       {
63670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63671       };
63672     }
63673   }
63674
63675 }
63676
63677
63678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63680   Dali::Property::Map *arg2 = 0 ;
63681
63682   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63683   arg2 = (Dali::Property::Map *)jarg2;
63684   if (!arg2) {
63685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63686     return ;
63687   }
63688   {
63689     try {
63690       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63691     } catch (std::out_of_range& e) {
63692       {
63693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63694       };
63695     } catch (std::exception& e) {
63696       {
63697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63698       };
63699     } catch (Dali::DaliException e) {
63700       {
63701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63702       };
63703     } catch (...) {
63704       {
63705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63706       };
63707     }
63708   }
63709
63710 }
63711
63712
63713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63715
63716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63717   {
63718     try {
63719       (arg1)->ClearBackground();
63720     } catch (std::out_of_range& e) {
63721       {
63722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63723       };
63724     } catch (std::exception& e) {
63725       {
63726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63727       };
63728     } catch (Dali::DaliException e) {
63729       {
63730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63731       };
63732     } catch (...) {
63733       {
63734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63735       };
63736     }
63737   }
63738
63739 }
63740
63741
63742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63743   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63744   Dali::Gesture::Type arg2 ;
63745
63746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63747   arg2 = (Dali::Gesture::Type)jarg2;
63748   {
63749     try {
63750       (arg1)->EnableGestureDetection(arg2);
63751     } catch (std::out_of_range& e) {
63752       {
63753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63754       };
63755     } catch (std::exception& e) {
63756       {
63757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63758       };
63759     } catch (Dali::DaliException e) {
63760       {
63761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63762       };
63763     } catch (...) {
63764       {
63765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63766       };
63767     }
63768   }
63769
63770 }
63771
63772
63773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63775   Dali::Gesture::Type arg2 ;
63776
63777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63778   arg2 = (Dali::Gesture::Type)jarg2;
63779   {
63780     try {
63781       (arg1)->DisableGestureDetection(arg2);
63782     } catch (std::out_of_range& e) {
63783       {
63784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63785       };
63786     } catch (std::exception& e) {
63787       {
63788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63789       };
63790     } catch (Dali::DaliException e) {
63791       {
63792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63793       };
63794     } catch (...) {
63795       {
63796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63797       };
63798     }
63799   }
63800
63801 }
63802
63803
63804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63805   void * jresult ;
63806   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63807   Dali::PinchGestureDetector result;
63808
63809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63810   {
63811     try {
63812       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63813     } catch (std::out_of_range& e) {
63814       {
63815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63816       };
63817     } catch (std::exception& e) {
63818       {
63819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63820       };
63821     } catch (Dali::DaliException e) {
63822       {
63823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63824       };
63825     } catch (...) {
63826       {
63827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63828       };
63829     }
63830   }
63831
63832   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63833   return jresult;
63834 }
63835
63836
63837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63838   void * jresult ;
63839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63840   Dali::PanGestureDetector result;
63841
63842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63843   {
63844     try {
63845       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63846     } catch (std::out_of_range& e) {
63847       {
63848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63849       };
63850     } catch (std::exception& e) {
63851       {
63852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63853       };
63854     } catch (Dali::DaliException e) {
63855       {
63856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63857       };
63858     } catch (...) {
63859       {
63860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63861       };
63862     }
63863   }
63864
63865   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63866   return jresult;
63867 }
63868
63869
63870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63871   void * jresult ;
63872   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63873   Dali::TapGestureDetector result;
63874
63875   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63876   {
63877     try {
63878       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63879     } catch (std::out_of_range& e) {
63880       {
63881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63882       };
63883     } catch (std::exception& e) {
63884       {
63885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63886       };
63887     } catch (Dali::DaliException e) {
63888       {
63889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63890       };
63891     } catch (...) {
63892       {
63893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63894       };
63895     }
63896   }
63897
63898   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63899   return jresult;
63900 }
63901
63902
63903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63904   void * jresult ;
63905   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63906   Dali::LongPressGestureDetector result;
63907
63908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63909   {
63910     try {
63911       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63912     } catch (std::out_of_range& e) {
63913       {
63914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63915       };
63916     } catch (std::exception& e) {
63917       {
63918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63919       };
63920     } catch (Dali::DaliException e) {
63921       {
63922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63923       };
63924     } catch (...) {
63925       {
63926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63927       };
63928     }
63929   }
63930
63931   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63932   return jresult;
63933 }
63934
63935
63936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63938   bool arg2 ;
63939
63940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63941   arg2 = jarg2 ? true : false;
63942   {
63943     try {
63944       (arg1)->SetKeyboardNavigationSupport(arg2);
63945     } catch (std::out_of_range& e) {
63946       {
63947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63948       };
63949     } catch (std::exception& e) {
63950       {
63951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63952       };
63953     } catch (Dali::DaliException e) {
63954       {
63955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63956       };
63957     } catch (...) {
63958       {
63959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63960       };
63961     }
63962   }
63963
63964 }
63965
63966
63967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63968   unsigned int jresult ;
63969   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63970   bool result;
63971
63972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63973   {
63974     try {
63975       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63976     } catch (std::out_of_range& e) {
63977       {
63978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63979       };
63980     } catch (std::exception& e) {
63981       {
63982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63983       };
63984     } catch (Dali::DaliException e) {
63985       {
63986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63987       };
63988     } catch (...) {
63989       {
63990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63991       };
63992     }
63993   }
63994
63995   jresult = result;
63996   return jresult;
63997 }
63998
63999
64000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
64001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64002
64003   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64004   {
64005     try {
64006       (arg1)->SetKeyInputFocus();
64007     } catch (std::out_of_range& e) {
64008       {
64009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64010       };
64011     } catch (std::exception& e) {
64012       {
64013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64014       };
64015     } catch (Dali::DaliException e) {
64016       {
64017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64018       };
64019     } catch (...) {
64020       {
64021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64022       };
64023     }
64024   }
64025
64026 }
64027
64028
64029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
64030   unsigned int jresult ;
64031   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64032   bool result;
64033
64034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64035   {
64036     try {
64037       result = (bool)(arg1)->HasKeyInputFocus();
64038     } catch (std::out_of_range& e) {
64039       {
64040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64041       };
64042     } catch (std::exception& e) {
64043       {
64044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64045       };
64046     } catch (Dali::DaliException e) {
64047       {
64048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64049       };
64050     } catch (...) {
64051       {
64052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64053       };
64054     }
64055   }
64056
64057   jresult = result;
64058   return jresult;
64059 }
64060
64061
64062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
64063   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64064
64065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64066   {
64067     try {
64068       (arg1)->ClearKeyInputFocus();
64069     } catch (std::out_of_range& e) {
64070       {
64071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64072       };
64073     } catch (std::exception& e) {
64074       {
64075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64076       };
64077     } catch (Dali::DaliException e) {
64078       {
64079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64080       };
64081     } catch (...) {
64082       {
64083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64084       };
64085     }
64086   }
64087
64088 }
64089
64090
64091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
64092   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64093   bool arg2 ;
64094
64095   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64096   arg2 = jarg2 ? true : false;
64097   {
64098     try {
64099       (arg1)->SetAsKeyboardFocusGroup(arg2);
64100     } catch (std::out_of_range& e) {
64101       {
64102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64103       };
64104     } catch (std::exception& e) {
64105       {
64106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64107       };
64108     } catch (Dali::DaliException e) {
64109       {
64110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64111       };
64112     } catch (...) {
64113       {
64114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64115       };
64116     }
64117   }
64118
64119 }
64120
64121
64122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
64123   unsigned int jresult ;
64124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64125   bool result;
64126
64127   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64128   {
64129     try {
64130       result = (bool)(arg1)->IsKeyboardFocusGroup();
64131     } catch (std::out_of_range& e) {
64132       {
64133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64134       };
64135     } catch (std::exception& e) {
64136       {
64137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64138       };
64139     } catch (Dali::DaliException e) {
64140       {
64141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64142       };
64143     } catch (...) {
64144       {
64145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64146       };
64147     }
64148   }
64149
64150   jresult = result;
64151   return jresult;
64152 }
64153
64154
64155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64156   void * jresult ;
64157   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64158   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64159
64160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64161   {
64162     try {
64163       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64164     } catch (std::out_of_range& e) {
64165       {
64166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64167       };
64168     } catch (std::exception& e) {
64169       {
64170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64171       };
64172     } catch (Dali::DaliException e) {
64173       {
64174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64175       };
64176     } catch (...) {
64177       {
64178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64179       };
64180     }
64181   }
64182
64183   jresult = (void *)result;
64184   return jresult;
64185 }
64186
64187
64188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64189   void * jresult ;
64190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64191   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64192
64193   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64194   {
64195     try {
64196       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64197     } catch (std::out_of_range& e) {
64198       {
64199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64200       };
64201     } catch (std::exception& e) {
64202       {
64203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64204       };
64205     } catch (Dali::DaliException e) {
64206       {
64207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64208       };
64209     } catch (...) {
64210       {
64211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64212       };
64213     }
64214   }
64215
64216   jresult = (void *)result;
64217   return jresult;
64218 }
64219
64220
64221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64222   void * jresult ;
64223   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64224   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64225
64226   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64227   {
64228     try {
64229       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64230     } catch (std::out_of_range& e) {
64231       {
64232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64233       };
64234     } catch (std::exception& e) {
64235       {
64236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64237       };
64238     } catch (Dali::DaliException e) {
64239       {
64240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64241       };
64242     } catch (...) {
64243       {
64244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64245       };
64246     }
64247   }
64248
64249   jresult = (void *)result;
64250   return jresult;
64251 }
64252
64253
64254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64255   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64256   int arg2 ;
64257   SwigDirector_ViewImpl *darg = 0;
64258
64259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64260   arg2 = (int)jarg2;
64261   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64262   if(!darg) {
64263     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64264     return;
64265   }
64266   {
64267     try {
64268       if(darg) {
64269         (darg)->OnStageConnection(arg2);
64270       }
64271     } catch (std::out_of_range& e) {
64272       {
64273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64274       };
64275     } catch (std::exception& e) {
64276       {
64277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64278       };
64279     } catch (Dali::DaliException e) {
64280       {
64281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64282       };
64283     } catch (...) {
64284       {
64285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64286       };
64287     }
64288   }
64289
64290 }
64291
64292
64293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64294   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64295   int arg2 ;
64296   SwigDirector_ViewImpl *darg = 0;
64297
64298   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64299   arg2 = (int)jarg2;
64300   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64301   if(!darg) {
64302     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64303     return;
64304   }
64305   {
64306     try {
64307       if(darg) {
64308         (darg)->OnStageConnectionSwigPublic(arg2);
64309       }
64310     } catch (std::out_of_range& e) {
64311       {
64312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64313       };
64314     } catch (std::exception& e) {
64315       {
64316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64317       };
64318     } catch (Dali::DaliException e) {
64319       {
64320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64321       };
64322     } catch (...) {
64323       {
64324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64325       };
64326     }
64327   }
64328
64329 }
64330
64331
64332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64334   SwigDirector_ViewImpl *darg = 0;
64335
64336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64337   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64338   if(!darg) {
64339     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64340     return;
64341   }
64342   {
64343     try {
64344       if(darg) {
64345         (darg)->OnStageDisconnection();
64346       }
64347     } catch (std::out_of_range& e) {
64348       {
64349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64350       };
64351     } catch (std::exception& e) {
64352       {
64353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64354       };
64355     } catch (Dali::DaliException e) {
64356       {
64357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64358       };
64359     } catch (...) {
64360       {
64361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64362       };
64363     }
64364   }
64365
64366 }
64367
64368
64369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64370   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64371   SwigDirector_ViewImpl *darg = 0;
64372
64373   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64374   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64375   if(!darg) {
64376     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64377     return;
64378   }
64379   {
64380     try {
64381       if(darg) {
64382         (darg)->OnStageDisconnectionSwigPublic();
64383       }
64384     } catch (std::out_of_range& e) {
64385       {
64386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64387       };
64388     } catch (std::exception& e) {
64389       {
64390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64391       };
64392     } catch (Dali::DaliException e) {
64393       {
64394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64395       };
64396     } catch (...) {
64397       {
64398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64399       };
64400     }
64401   }
64402
64403 }
64404
64405
64406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64408   Dali::Actor *arg2 = 0 ;
64409   SwigDirector_ViewImpl *darg = 0;
64410
64411   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64412   arg2 = (Dali::Actor *)jarg2;
64413   if (!arg2) {
64414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64415     return ;
64416   }
64417   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64418   if(!darg) {
64419     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64420     return;
64421   }
64422   {
64423     try {
64424       if(darg) {
64425         (darg)->OnChildAdd(*arg2);
64426       }
64427     } catch (std::out_of_range& e) {
64428       {
64429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64430       };
64431     } catch (std::exception& e) {
64432       {
64433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64434       };
64435     } catch (Dali::DaliException e) {
64436       {
64437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64438       };
64439     } catch (...) {
64440       {
64441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64442       };
64443     }
64444   }
64445
64446 }
64447
64448
64449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64450   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64451   Dali::Actor *arg2 = 0 ;
64452   SwigDirector_ViewImpl *darg = 0;
64453
64454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64455   arg2 = (Dali::Actor *)jarg2;
64456   if (!arg2) {
64457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64458     return ;
64459   }
64460   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64461   if(!darg) {
64462     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64463     return;
64464   }
64465   {
64466     try {
64467       if(darg) {
64468           (darg)->OnChildAddSwigPublic(*arg2);
64469       }
64470     } catch (std::out_of_range& e) {
64471       {
64472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64473       };
64474     } catch (std::exception& e) {
64475       {
64476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64477       };
64478     } catch (Dali::DaliException e) {
64479       {
64480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64481       };
64482     } catch (...) {
64483       {
64484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64485       };
64486     }
64487   }
64488
64489 }
64490
64491
64492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64493   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64494   Dali::Actor *arg2 = 0 ;
64495   SwigDirector_ViewImpl *darg = 0;
64496
64497   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64498   arg2 = (Dali::Actor *)jarg2;
64499   if (!arg2) {
64500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64501     return ;
64502   }
64503   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64504   if(!darg) {
64505     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64506     return;
64507   }
64508   {
64509     try {
64510       if(darg) {
64511         (darg)->OnChildRemove(*arg2);
64512       }
64513     } catch (std::out_of_range& e) {
64514       {
64515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64516       };
64517     } catch (std::exception& e) {
64518       {
64519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64520       };
64521     } catch (Dali::DaliException e) {
64522       {
64523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64524       };
64525     } catch (...) {
64526       {
64527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64528       };
64529     }
64530   }
64531
64532 }
64533
64534
64535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64537   Dali::Actor *arg2 = 0 ;
64538   SwigDirector_ViewImpl *darg = 0;
64539
64540   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64541   arg2 = (Dali::Actor *)jarg2;
64542   if (!arg2) {
64543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64544     return ;
64545   }
64546   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64547   if(!darg) {
64548     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64549     return;
64550   }
64551   {
64552     try {
64553       if(darg) {
64554         (darg)->OnChildRemoveSwigPublic(*arg2);
64555       }
64556     } catch (std::out_of_range& e) {
64557       {
64558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64559       };
64560     } catch (std::exception& e) {
64561       {
64562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64563       };
64564     } catch (Dali::DaliException e) {
64565       {
64566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64567       };
64568     } catch (...) {
64569       {
64570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64571       };
64572     }
64573   }
64574
64575 }
64576
64577
64578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64579   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64580   Dali::Property::Index arg2 ;
64581   Dali::Property::Value arg3 ;
64582   Dali::Property::Value *argp3 ;
64583   SwigDirector_ViewImpl *darg = 0;
64584
64585   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64586   arg2 = (Dali::Property::Index)jarg2;
64587   argp3 = (Dali::Property::Value *)jarg3;
64588   if (!argp3) {
64589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64590     return ;
64591   }
64592   arg3 = *argp3;
64593   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64594   if (!darg) {
64595     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64596     return;
64597   }
64598   {
64599     try {
64600       (darg)->OnPropertySet(arg2,arg3);
64601     } catch (std::out_of_range& e) {
64602       {
64603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64604       };
64605     } catch (std::exception& e) {
64606       {
64607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64608       };
64609     } catch (Dali::DaliException e) {
64610       {
64611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64612       };
64613     } catch (...) {
64614       {
64615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64616       };
64617     }
64618   }
64619
64620 }
64621
64622
64623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64625   Dali::Property::Index arg2 ;
64626   Dali::Property::Value arg3 ;
64627   Dali::Property::Value *argp3 ;
64628   SwigDirector_ViewImpl *darg = 0;
64629
64630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64631   arg2 = (Dali::Property::Index)jarg2;
64632   argp3 = (Dali::Property::Value *)jarg3;
64633   if (!argp3) {
64634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64635     return ;
64636   }
64637   arg3 = *argp3;
64638   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64639   if (!darg) {
64640     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64641     return;
64642   }
64643   {
64644     try {
64645       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64646     } catch (std::out_of_range& e) {
64647       {
64648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64649       };
64650     } catch (std::exception& e) {
64651       {
64652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64653       };
64654     } catch (Dali::DaliException e) {
64655       {
64656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64657       };
64658     } catch (...) {
64659       {
64660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64661       };
64662     }
64663   }
64664
64665 }
64666
64667
64668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64670   Dali::Vector3 *arg2 = 0 ;
64671   SwigDirector_ViewImpl *darg = 0;
64672
64673   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64674   arg2 = (Dali::Vector3 *)jarg2;
64675   if (!arg2) {
64676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64677     return ;
64678   }
64679   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64680   if (!darg) {
64681     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64682     return;
64683   }
64684   {
64685     try {
64686       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64687     } catch (std::out_of_range& e) {
64688       {
64689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64690       };
64691     } catch (std::exception& e) {
64692       {
64693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64694       };
64695     } catch (Dali::DaliException e) {
64696       {
64697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64698       };
64699     } catch (...) {
64700       {
64701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64702       };
64703     }
64704   }
64705
64706 }
64707
64708
64709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64711   Dali::Vector3 *arg2 = 0 ;
64712   SwigDirector_ViewImpl *darg = 0;
64713
64714   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64715   arg2 = (Dali::Vector3 *)jarg2;
64716   if (!arg2) {
64717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64718     return ;
64719   }
64720   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64721   if (!darg) {
64722     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64723     return;
64724   }
64725   {
64726     try {
64727       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64728     } catch (std::out_of_range& e) {
64729       {
64730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64731       };
64732     } catch (std::exception& e) {
64733       {
64734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64735       };
64736     } catch (Dali::DaliException e) {
64737       {
64738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64739       };
64740     } catch (...) {
64741       {
64742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64743       };
64744     }
64745   }
64746
64747 }
64748
64749
64750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64751   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64752   Dali::Animation *arg2 = 0 ;
64753   Dali::Vector3 *arg3 = 0 ;
64754   SwigDirector_ViewImpl *darg = 0;
64755
64756   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64757   arg2 = (Dali::Animation *)jarg2;
64758   if (!arg2) {
64759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64760     return ;
64761   }
64762   arg3 = (Dali::Vector3 *)jarg3;
64763   if (!arg3) {
64764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64765     return ;
64766   }
64767   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64768   if (!darg) {
64769     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64770     return;
64771   }
64772   {
64773     try {
64774       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64775     } catch (std::out_of_range& e) {
64776       {
64777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64778       };
64779     } catch (std::exception& e) {
64780       {
64781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64782       };
64783     } catch (Dali::DaliException e) {
64784       {
64785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64786       };
64787     } catch (...) {
64788       {
64789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64790       };
64791     }
64792   }
64793
64794 }
64795
64796
64797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64798   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64799   Dali::Animation *arg2 = 0 ;
64800   Dali::Vector3 *arg3 = 0 ;
64801   SwigDirector_ViewImpl *darg = 0;
64802
64803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64804   arg2 = (Dali::Animation *)jarg2;
64805   if (!arg2) {
64806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64807     return ;
64808   }
64809   arg3 = (Dali::Vector3 *)jarg3;
64810   if (!arg3) {
64811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64812     return ;
64813   }
64814   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64815   if (!darg) {
64816     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64817     return;
64818   }
64819   {
64820     try {
64821       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64822     } catch (std::out_of_range& e) {
64823       {
64824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64825       };
64826     } catch (std::exception& e) {
64827       {
64828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64829       };
64830     } catch (Dali::DaliException e) {
64831       {
64832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64833       };
64834     } catch (...) {
64835       {
64836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64837       };
64838     }
64839   }
64840
64841 }
64842
64843
64844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64845   unsigned int jresult ;
64846   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64847   Dali::TouchEvent *arg2 = 0 ;
64848   SwigDirector_ViewImpl *darg = 0;
64849   bool result;
64850
64851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64852   arg2 = (Dali::TouchEvent *)jarg2;
64853   if (!arg2) {
64854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64855     return 0;
64856   }
64857   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64858   if (!darg) {
64859     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64860     return 0;
64861   }
64862   {
64863     try {
64864       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64865     } catch (std::out_of_range& e) {
64866       {
64867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64868       };
64869     } catch (std::exception& e) {
64870       {
64871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64872       };
64873     } catch (Dali::DaliException e) {
64874       {
64875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64876       };
64877     } catch (...) {
64878       {
64879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64880       };
64881     }
64882   }
64883
64884   jresult = result;
64885   return jresult;
64886 }
64887
64888
64889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64890   unsigned int jresult ;
64891   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64892   Dali::TouchEvent *arg2 = 0 ;
64893   SwigDirector_ViewImpl *darg = 0;
64894   bool result;
64895
64896   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64897   arg2 = (Dali::TouchEvent *)jarg2;
64898   if (!arg2) {
64899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64900     return 0;
64901   }
64902   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64903   if (!darg) {
64904     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64905     return 0;
64906   }
64907   {
64908     try {
64909       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64910     } catch (std::out_of_range& e) {
64911       {
64912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64913       };
64914     } catch (std::exception& e) {
64915       {
64916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64917       };
64918     } catch (Dali::DaliException e) {
64919       {
64920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64921       };
64922     } catch (...) {
64923       {
64924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64925       };
64926     }
64927   }
64928
64929   jresult = result;
64930   return jresult;
64931 }
64932
64933
64934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64935   unsigned int jresult ;
64936   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64937   Dali::HoverEvent *arg2 = 0 ;
64938   SwigDirector_ViewImpl *darg = 0;
64939   bool result;
64940
64941   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64942   arg2 = (Dali::HoverEvent *)jarg2;
64943   if (!arg2) {
64944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64945     return 0;
64946   }
64947   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64948   if (!darg) {
64949     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64950     return 0;
64951   }
64952   {
64953     try {
64954       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64955     } catch (std::out_of_range& e) {
64956       {
64957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64958       };
64959     } catch (std::exception& e) {
64960       {
64961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64962       };
64963     } catch (Dali::DaliException e) {
64964       {
64965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64966       };
64967     } catch (...) {
64968       {
64969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64970       };
64971     }
64972   }
64973
64974   jresult = result;
64975   return jresult;
64976 }
64977
64978
64979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64980   unsigned int jresult ;
64981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64982   Dali::HoverEvent *arg2 = 0 ;
64983   SwigDirector_ViewImpl *darg = 0;
64984   bool result;
64985
64986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64987   arg2 = (Dali::HoverEvent *)jarg2;
64988   if (!arg2) {
64989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64990     return 0;
64991   }
64992   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64993   if (!darg) {
64994     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64995     return 0;
64996   }
64997   {
64998     try {
64999       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
65000     } catch (std::out_of_range& e) {
65001       {
65002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65003       };
65004     } catch (std::exception& e) {
65005       {
65006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65007       };
65008     } catch (Dali::DaliException e) {
65009       {
65010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65011       };
65012     } catch (...) {
65013       {
65014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65015       };
65016     }
65017   }
65018
65019   jresult = result;
65020   return jresult;
65021 }
65022
65023
65024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
65025   unsigned int jresult ;
65026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65027   Dali::KeyEvent *arg2 = 0 ;
65028   SwigDirector_ViewImpl *darg = 0;
65029   bool result;
65030
65031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65032   arg2 = (Dali::KeyEvent *)jarg2;
65033   if (!arg2) {
65034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65035     return 0;
65036   }
65037   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65038   if (!darg) {
65039     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65040     return 0;
65041   }
65042   {
65043     try {
65044       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
65045     } catch (std::out_of_range& e) {
65046       {
65047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65048       };
65049     } catch (std::exception& e) {
65050       {
65051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65052       };
65053     } catch (Dali::DaliException e) {
65054       {
65055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65056       };
65057     } catch (...) {
65058       {
65059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65060       };
65061     }
65062   }
65063
65064   jresult = result;
65065   return jresult;
65066 }
65067
65068
65069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65070   unsigned int jresult ;
65071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65072   Dali::KeyEvent *arg2 = 0 ;
65073   SwigDirector_ViewImpl *darg = 0;
65074   bool result;
65075
65076   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65077   arg2 = (Dali::KeyEvent *)jarg2;
65078   if (!arg2) {
65079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65080     return 0;
65081   }
65082   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65083   if (!darg) {
65084     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65085     return 0;
65086   }
65087   {
65088     try {
65089       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
65090     } catch (std::out_of_range& e) {
65091       {
65092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65093       };
65094     } catch (std::exception& e) {
65095       {
65096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65097       };
65098     } catch (Dali::DaliException e) {
65099       {
65100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65101       };
65102     } catch (...) {
65103       {
65104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65105       };
65106     }
65107   }
65108
65109   jresult = result;
65110   return jresult;
65111 }
65112
65113
65114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
65115   unsigned int jresult ;
65116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65117   Dali::WheelEvent *arg2 = 0 ;
65118   SwigDirector_ViewImpl *darg = 0;
65119   bool result;
65120
65121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65122   arg2 = (Dali::WheelEvent *)jarg2;
65123   if (!arg2) {
65124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65125     return 0;
65126   }
65127   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65128   if (!darg) {
65129     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65130     return 0;
65131   }
65132   {
65133     try {
65134       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
65135     } catch (std::out_of_range& e) {
65136       {
65137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65138       };
65139     } catch (std::exception& e) {
65140       {
65141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65142       };
65143     } catch (Dali::DaliException e) {
65144       {
65145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65146       };
65147     } catch (...) {
65148       {
65149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65150       };
65151     }
65152   }
65153
65154   jresult = result;
65155   return jresult;
65156 }
65157
65158
65159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65160   unsigned int jresult ;
65161   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65162   Dali::WheelEvent *arg2 = 0 ;
65163   SwigDirector_ViewImpl *darg = 0;
65164   bool result;
65165
65166   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65167   arg2 = (Dali::WheelEvent *)jarg2;
65168   if (!arg2) {
65169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65170     return 0;
65171   }
65172   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65173   if (!darg) {
65174     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65175     return 0;
65176   }
65177   {
65178     try {
65179       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
65180     } catch (std::out_of_range& e) {
65181       {
65182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65183       };
65184     } catch (std::exception& e) {
65185       {
65186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65187       };
65188     } catch (Dali::DaliException e) {
65189       {
65190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65191       };
65192     } catch (...) {
65193       {
65194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65195       };
65196     }
65197   }
65198
65199   jresult = result;
65200   return jresult;
65201 }
65202
65203
65204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65205   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65206   Dali::Vector2 *arg2 = 0 ;
65207   Dali::RelayoutContainer *arg3 = 0 ;
65208   SwigDirector_ViewImpl *darg = 0;
65209
65210   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65211   arg2 = (Dali::Vector2 *)jarg2;
65212   if (!arg2) {
65213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65214     return ;
65215   }
65216   arg3 = (Dali::RelayoutContainer *)jarg3;
65217   if (!arg3) {
65218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65219     return ;
65220   }
65221   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65222   if (!darg) {
65223     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65224     return;
65225   }
65226   {
65227     try {
65228       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65229     } catch (std::out_of_range& e) {
65230       {
65231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65232       };
65233     } catch (std::exception& e) {
65234       {
65235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65236       };
65237     } catch (Dali::DaliException e) {
65238       {
65239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65240       };
65241     } catch (...) {
65242       {
65243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65244       };
65245     }
65246   }
65247
65248 }
65249
65250
65251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65253   Dali::Vector2 *arg2 = 0 ;
65254   Dali::RelayoutContainer *arg3 = 0 ;
65255   SwigDirector_ViewImpl *darg = 0;
65256
65257   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65258   arg2 = (Dali::Vector2 *)jarg2;
65259   if (!arg2) {
65260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65261     return ;
65262   }
65263   arg3 = (Dali::RelayoutContainer *)jarg3;
65264   if (!arg3) {
65265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65266     return ;
65267   }
65268   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65269   if (!darg) {
65270     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65271     return;
65272   }
65273   {
65274     try {
65275       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65276     } catch (std::out_of_range& e) {
65277       {
65278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65279       };
65280     } catch (std::exception& e) {
65281       {
65282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65283       };
65284     } catch (Dali::DaliException e) {
65285       {
65286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65287       };
65288     } catch (...) {
65289       {
65290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65291       };
65292     }
65293   }
65294
65295 }
65296
65297
65298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65300   Dali::ResizePolicy::Type arg2 ;
65301   Dali::Dimension::Type arg3 ;
65302   SwigDirector_ViewImpl *darg = 0;
65303
65304   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65305   arg2 = (Dali::ResizePolicy::Type)jarg2;
65306   arg3 = (Dali::Dimension::Type)jarg3;
65307   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65308   if (!darg) {
65309     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65310     return;
65311   }
65312   {
65313     try {
65314       (darg)->OnSetResizePolicy(arg2,arg3);
65315     } catch (std::out_of_range& e) {
65316       {
65317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65318       };
65319     } catch (std::exception& e) {
65320       {
65321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65322       };
65323     } catch (Dali::DaliException e) {
65324       {
65325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65326       };
65327     } catch (...) {
65328       {
65329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65330       };
65331     }
65332   }
65333
65334 }
65335
65336
65337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65338   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65339   Dali::ResizePolicy::Type arg2 ;
65340   Dali::Dimension::Type arg3 ;
65341   SwigDirector_ViewImpl *darg = 0;
65342
65343   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65344   arg2 = (Dali::ResizePolicy::Type)jarg2;
65345   arg3 = (Dali::Dimension::Type)jarg3;
65346   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65347   if (!darg) {
65348     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65349     return;
65350   }
65351   {
65352     try {
65353       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65354     } catch (std::out_of_range& e) {
65355       {
65356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65357       };
65358     } catch (std::exception& e) {
65359       {
65360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65361       };
65362     } catch (Dali::DaliException e) {
65363       {
65364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65365       };
65366     } catch (...) {
65367       {
65368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65369       };
65370     }
65371   }
65372
65373 }
65374
65375
65376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65377   void * jresult ;
65378   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65379   SwigDirector_ViewImpl *darg = 0;
65380   Dali::Vector3 result;
65381
65382   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65383   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65384   if (!darg) {
65385     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65386     return 0;
65387   }
65388   {
65389     try {
65390       result = (darg)->GetNaturalSize();
65391     } catch (std::out_of_range& e) {
65392       {
65393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65394       };
65395     } catch (std::exception& e) {
65396       {
65397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65398       };
65399     } catch (Dali::DaliException e) {
65400       {
65401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65402       };
65403     } catch (...) {
65404       {
65405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65406       };
65407     }
65408   }
65409
65410   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65411   return jresult;
65412 }
65413
65414
65415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65416   void * jresult ;
65417   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65418   SwigDirector_ViewImpl *darg = 0;
65419   Dali::Vector3 result;
65420
65421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65422   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65423   if (!darg) {
65424     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65425     return 0;
65426   }
65427   {
65428     try {
65429       result = (darg)->GetNaturalSizeSwigPublic();
65430     } catch (std::out_of_range& e) {
65431       {
65432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65433       };
65434     } catch (std::exception& e) {
65435       {
65436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65437       };
65438     } catch (Dali::DaliException e) {
65439       {
65440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65441       };
65442     } catch (...) {
65443       {
65444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65445       };
65446     }
65447   }
65448
65449   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65450   return jresult;
65451 }
65452
65453
65454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65455   float jresult ;
65456   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65457   Dali::Actor *arg2 = 0 ;
65458   Dali::Dimension::Type arg3 ;
65459   SwigDirector_ViewImpl *darg = 0;
65460   float result;
65461
65462   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65463   arg2 = (Dali::Actor *)jarg2;
65464   if (!arg2) {
65465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65466     return 0;
65467   }
65468   arg3 = (Dali::Dimension::Type)jarg3;
65469   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65470   if (!darg) {
65471     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65472     return 0;
65473   }
65474   {
65475     try {
65476       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65477     } catch (std::out_of_range& e) {
65478       {
65479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65480       };
65481     } catch (std::exception& e) {
65482       {
65483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65484       };
65485     } catch (Dali::DaliException e) {
65486       {
65487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65488       };
65489     } catch (...) {
65490       {
65491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65492       };
65493     }
65494   }
65495
65496   jresult = result;
65497   return jresult;
65498 }
65499
65500
65501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65502   float jresult ;
65503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65504   Dali::Actor *arg2 = 0 ;
65505   Dali::Dimension::Type arg3 ;
65506   SwigDirector_ViewImpl *darg = 0;
65507   float result;
65508
65509   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65510   arg2 = (Dali::Actor *)jarg2;
65511   if (!arg2) {
65512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65513     return 0;
65514   }
65515   arg3 = (Dali::Dimension::Type)jarg3;
65516   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65517   if (!darg) {
65518     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65519     return 0;
65520   }
65521   {
65522     try {
65523       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65524     } catch (std::out_of_range& e) {
65525       {
65526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65527       };
65528     } catch (std::exception& e) {
65529       {
65530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65531       };
65532     } catch (Dali::DaliException e) {
65533       {
65534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65535       };
65536     } catch (...) {
65537       {
65538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65539       };
65540     }
65541   }
65542
65543   jresult = result;
65544   return jresult;
65545 }
65546
65547
65548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65549   float jresult ;
65550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65551   float arg2 ;
65552   SwigDirector_ViewImpl *darg = 0;
65553   float result;
65554
65555   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65556   arg2 = (float)jarg2;
65557   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65558   if (!darg) {
65559     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65560     return 0;
65561   }
65562   {
65563     try {
65564       result = (float)(darg)->GetHeightForWidth(arg2);
65565     } catch (std::out_of_range& e) {
65566       {
65567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65568       };
65569     } catch (std::exception& e) {
65570       {
65571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65572       };
65573     } catch (Dali::DaliException e) {
65574       {
65575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65576       };
65577     } catch (...) {
65578       {
65579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65580       };
65581     }
65582   }
65583
65584   jresult = result;
65585   return jresult;
65586 }
65587
65588
65589 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65590   float jresult ;
65591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65592   float arg2 ;
65593   SwigDirector_ViewImpl *darg = 0;
65594   float result;
65595
65596   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65597   arg2 = (float)jarg2;
65598   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65599   if (!darg) {
65600     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65601     return 0;
65602   }
65603   {
65604     try {
65605       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65606     } catch (std::out_of_range& e) {
65607       {
65608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65609       };
65610     } catch (std::exception& e) {
65611       {
65612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65613       };
65614     } catch (Dali::DaliException e) {
65615       {
65616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65617       };
65618     } catch (...) {
65619       {
65620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65621       };
65622     }
65623   }
65624
65625   jresult = result;
65626   return jresult;
65627 }
65628
65629
65630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65631   float jresult ;
65632   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65633   float arg2 ;
65634   SwigDirector_ViewImpl *darg = 0;
65635   float result;
65636
65637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65638   arg2 = (float)jarg2;
65639   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65640   if (!darg) {
65641     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65642     return 0;
65643   }
65644   {
65645     try {
65646       result = (float)(darg)->GetWidthForHeight(arg2);
65647     } catch (std::out_of_range& e) {
65648       {
65649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65650       };
65651     } catch (std::exception& e) {
65652       {
65653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65654       };
65655     } catch (Dali::DaliException e) {
65656       {
65657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65658       };
65659     } catch (...) {
65660       {
65661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65662       };
65663     }
65664   }
65665
65666   jresult = result;
65667   return jresult;
65668 }
65669
65670
65671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65672   float jresult ;
65673   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65674   float arg2 ;
65675   SwigDirector_ViewImpl *darg = 0;
65676   float result;
65677
65678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65679   arg2 = (float)jarg2;
65680   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65681   if (!darg) {
65682     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65683     return 0;
65684   }
65685   {
65686     try {
65687       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65688     } catch (std::out_of_range& e) {
65689       {
65690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65691       };
65692     } catch (std::exception& e) {
65693       {
65694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65695       };
65696     } catch (Dali::DaliException e) {
65697       {
65698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65699       };
65700     } catch (...) {
65701       {
65702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65703       };
65704     }
65705   }
65706
65707   jresult = result;
65708   return jresult;
65709 }
65710
65711
65712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65713   unsigned int jresult ;
65714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65715   Dali::Dimension::Type arg2 ;
65716   SwigDirector_ViewImpl *darg = 0;
65717   bool result;
65718
65719   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65720   arg2 = (Dali::Dimension::Type)jarg2;
65721   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65722   if (!darg) {
65723     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65724     return 0;
65725   }
65726   {
65727     try {
65728       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65729     } catch (std::out_of_range& e) {
65730       {
65731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65732       };
65733     } catch (std::exception& e) {
65734       {
65735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65736       };
65737     } catch (Dali::DaliException e) {
65738       {
65739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65740       };
65741     } catch (...) {
65742       {
65743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65744       };
65745     }
65746   }
65747
65748   jresult = result;
65749   return jresult;
65750 }
65751
65752
65753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65754   unsigned int jresult ;
65755   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65756   Dali::Dimension::Type arg2 ;
65757   SwigDirector_ViewImpl *darg = 0;
65758   bool result;
65759
65760   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65761   arg2 = (Dali::Dimension::Type)jarg2;
65762   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65763   if (!darg) {
65764     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65765     return 0;
65766   }
65767   {
65768     try {
65769       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65770     } catch (std::out_of_range& e) {
65771       {
65772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65773       };
65774     } catch (std::exception& e) {
65775       {
65776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65777       };
65778     } catch (Dali::DaliException e) {
65779       {
65780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65781       };
65782     } catch (...) {
65783       {
65784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65785       };
65786     }
65787   }
65788
65789   jresult = result;
65790   return jresult;
65791 }
65792
65793
65794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65795   unsigned int jresult ;
65796   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65797   SwigDirector_ViewImpl *darg = 0;
65798   bool result;
65799
65800   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65801   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65802   if (!darg) {
65803     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65804     return 0;
65805   }
65806   {
65807     try {
65808       result = (bool)(darg)->RelayoutDependentOnChildren();
65809     } catch (std::out_of_range& e) {
65810       {
65811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65812       };
65813     } catch (std::exception& e) {
65814       {
65815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65816       };
65817     } catch (Dali::DaliException e) {
65818       {
65819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65820       };
65821     } catch (...) {
65822       {
65823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65824       };
65825     }
65826   }
65827
65828   jresult = result;
65829   return jresult;
65830 }
65831
65832
65833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65834   unsigned int jresult ;
65835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65836   SwigDirector_ViewImpl *darg = 0;
65837   bool result;
65838
65839   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65840   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65841   if (!darg) {
65842     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65843     return 0;
65844   }
65845   {
65846     try {
65847       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65848     } catch (std::out_of_range& e) {
65849       {
65850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65851       };
65852     } catch (std::exception& e) {
65853       {
65854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65855       };
65856     } catch (Dali::DaliException e) {
65857       {
65858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65859       };
65860     } catch (...) {
65861       {
65862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65863       };
65864     }
65865   }
65866
65867   jresult = result;
65868   return jresult;
65869 }
65870
65871
65872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65873   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65874   Dali::Dimension::Type arg2 ;
65875   SwigDirector_ViewImpl *darg = 0;
65876
65877   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65878   arg2 = (Dali::Dimension::Type)jarg2;
65879   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65880   if (!darg) {
65881     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65882     return;
65883   }
65884   {
65885     try {
65886       (darg)->OnCalculateRelayoutSize(arg2);
65887     } catch (std::out_of_range& e) {
65888       {
65889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65890       };
65891     } catch (std::exception& e) {
65892       {
65893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65894       };
65895     } catch (Dali::DaliException e) {
65896       {
65897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65898       };
65899     } catch (...) {
65900       {
65901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65902       };
65903     }
65904   }
65905
65906 }
65907
65908
65909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65911   Dali::Dimension::Type arg2 ;
65912   SwigDirector_ViewImpl *darg = 0;
65913
65914   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65915   arg2 = (Dali::Dimension::Type)jarg2;
65916   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65917   if (!darg) {
65918     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65919     return;
65920   }
65921   {
65922     try {
65923       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65924     } catch (std::out_of_range& e) {
65925       {
65926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65927       };
65928     } catch (std::exception& e) {
65929       {
65930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65931       };
65932     } catch (Dali::DaliException e) {
65933       {
65934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65935       };
65936     } catch (...) {
65937       {
65938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65939       };
65940     }
65941   }
65942
65943 }
65944
65945
65946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65947   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65948   float arg2 ;
65949   Dali::Dimension::Type arg3 ;
65950   SwigDirector_ViewImpl *darg = 0;
65951
65952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65953   arg2 = (float)jarg2;
65954   arg3 = (Dali::Dimension::Type)jarg3;
65955   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65956   if (!darg) {
65957     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65958     return;
65959   }
65960   {
65961     try {
65962       (darg)->OnLayoutNegotiated(arg2,arg3);
65963     } catch (std::out_of_range& e) {
65964       {
65965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65966       };
65967     } catch (std::exception& e) {
65968       {
65969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65970       };
65971     } catch (Dali::DaliException e) {
65972       {
65973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65974       };
65975     } catch (...) {
65976       {
65977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65978       };
65979     }
65980   }
65981
65982 }
65983
65984
65985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65987   float arg2 ;
65988   Dali::Dimension::Type arg3 ;
65989   SwigDirector_ViewImpl *darg = 0;
65990
65991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65992   arg2 = (float)jarg2;
65993   arg3 = (Dali::Dimension::Type)jarg3;
65994   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65995   if (!darg) {
65996     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65997     return;
65998   }
65999   {
66000     try {
66001       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
66002     } catch (std::out_of_range& e) {
66003       {
66004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66005       };
66006     } catch (std::exception& e) {
66007       {
66008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66009       };
66010     } catch (Dali::DaliException e) {
66011       {
66012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66013       };
66014     } catch (...) {
66015       {
66016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66017       };
66018     }
66019   }
66020
66021 }
66022
66023
66024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
66025   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66026
66027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66028   {
66029     try {
66030       (arg1)->OnInitialize();
66031     } catch (std::out_of_range& e) {
66032       {
66033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66034       };
66035     } catch (std::exception& e) {
66036       {
66037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66038       };
66039     } catch (Dali::DaliException e) {
66040       {
66041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66042       };
66043     } catch (...) {
66044       {
66045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66046       };
66047     }
66048   }
66049
66050 }
66051
66052
66053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
66054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66055
66056   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66057   {
66058     try {
66059       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
66060     } catch (std::out_of_range& e) {
66061       {
66062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66063       };
66064     } catch (std::exception& e) {
66065       {
66066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66067       };
66068     } catch (Dali::DaliException e) {
66069       {
66070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66071       };
66072     } catch (...) {
66073       {
66074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66075       };
66076     }
66077   }
66078
66079 }
66080
66081
66082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
66083   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66084   Dali::Actor *arg2 = 0 ;
66085
66086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66087   arg2 = (Dali::Actor *)jarg2;
66088   if (!arg2) {
66089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66090     return ;
66091   }
66092   {
66093     try {
66094       (arg1)->OnControlChildAdd(*arg2);
66095     } catch (std::out_of_range& e) {
66096       {
66097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66098       };
66099     } catch (std::exception& e) {
66100       {
66101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66102       };
66103     } catch (Dali::DaliException e) {
66104       {
66105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66106       };
66107     } catch (...) {
66108       {
66109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66110       };
66111     }
66112   }
66113
66114 }
66115
66116
66117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66118   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66119   Dali::Actor *arg2 = 0 ;
66120
66121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66122   arg2 = (Dali::Actor *)jarg2;
66123   if (!arg2) {
66124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66125     return ;
66126   }
66127   {
66128     try {
66129       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
66130     } catch (std::out_of_range& e) {
66131       {
66132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66133       };
66134     } catch (std::exception& e) {
66135       {
66136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66137       };
66138     } catch (Dali::DaliException e) {
66139       {
66140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66141       };
66142     } catch (...) {
66143       {
66144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66145       };
66146     }
66147   }
66148
66149 }
66150
66151
66152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
66153   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66154   Dali::Actor *arg2 = 0 ;
66155
66156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66157   arg2 = (Dali::Actor *)jarg2;
66158   if (!arg2) {
66159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66160     return ;
66161   }
66162   {
66163     try {
66164       (arg1)->OnControlChildRemove(*arg2);
66165     } catch (std::out_of_range& e) {
66166       {
66167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66168       };
66169     } catch (std::exception& e) {
66170       {
66171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66172       };
66173     } catch (Dali::DaliException e) {
66174       {
66175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66176       };
66177     } catch (...) {
66178       {
66179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66180       };
66181     }
66182   }
66183
66184 }
66185
66186
66187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66189   Dali::Actor *arg2 = 0 ;
66190
66191   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66192   arg2 = (Dali::Actor *)jarg2;
66193   if (!arg2) {
66194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66195     return ;
66196   }
66197   {
66198     try {
66199       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
66200     } catch (std::out_of_range& e) {
66201       {
66202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66203       };
66204     } catch (std::exception& e) {
66205       {
66206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66207       };
66208     } catch (Dali::DaliException e) {
66209       {
66210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66211       };
66212     } catch (...) {
66213       {
66214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66215       };
66216     }
66217   }
66218
66219 }
66220
66221
66222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
66223   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66224   Dali::Toolkit::StyleManager arg2 ;
66225   Dali::StyleChange::Type arg3 ;
66226   Dali::Toolkit::StyleManager *argp2 ;
66227
66228   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66229   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66230   if (!argp2) {
66231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66232     return ;
66233   }
66234   arg2 = *argp2;
66235   arg3 = (Dali::StyleChange::Type)jarg3;
66236   {
66237     try {
66238       (arg1)->OnStyleChange(arg2,arg3);
66239     } catch (std::out_of_range& e) {
66240       {
66241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66242       };
66243     } catch (std::exception& e) {
66244       {
66245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66246       };
66247     } catch (Dali::DaliException e) {
66248       {
66249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66250       };
66251     } catch (...) {
66252       {
66253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66254       };
66255     }
66256   }
66257
66258 }
66259
66260
66261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
66262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66263   Dali::Toolkit::StyleManager arg2 ;
66264   Dali::StyleChange::Type arg3 ;
66265   Dali::Toolkit::StyleManager *argp2 ;
66266
66267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66268   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66269   if (!argp2) {
66270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66271     return ;
66272   }
66273   arg2 = *argp2;
66274   arg3 = (Dali::StyleChange::Type)jarg3;
66275   {
66276     try {
66277       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66278     } catch (std::out_of_range& e) {
66279       {
66280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66281       };
66282     } catch (std::exception& e) {
66283       {
66284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66285       };
66286     } catch (Dali::DaliException e) {
66287       {
66288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66289       };
66290     } catch (...) {
66291       {
66292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66293       };
66294     }
66295   }
66296
66297 }
66298
66299
66300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66301   unsigned int jresult ;
66302   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66303   bool result;
66304
66305   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66306   {
66307     try {
66308       result = (bool)(arg1)->OnAccessibilityActivated();
66309     } catch (std::out_of_range& e) {
66310       {
66311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66312       };
66313     } catch (std::exception& e) {
66314       {
66315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66316       };
66317     } catch (Dali::DaliException e) {
66318       {
66319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66320       };
66321     } catch (...) {
66322       {
66323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66324       };
66325     }
66326   }
66327
66328   jresult = result;
66329   return jresult;
66330 }
66331
66332
66333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66334   unsigned int jresult ;
66335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66336   bool result;
66337
66338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66339   {
66340     try {
66341       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66342     } catch (std::out_of_range& e) {
66343       {
66344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66345       };
66346     } catch (std::exception& e) {
66347       {
66348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66349       };
66350     } catch (Dali::DaliException e) {
66351       {
66352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66353       };
66354     } catch (...) {
66355       {
66356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66357       };
66358     }
66359   }
66360
66361   jresult = result;
66362   return jresult;
66363 }
66364
66365
66366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66367   unsigned int jresult ;
66368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66369   Dali::PanGesture arg2 ;
66370   Dali::PanGesture *argp2 ;
66371   bool result;
66372
66373   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66374   argp2 = (Dali::PanGesture *)jarg2;
66375   if (!argp2) {
66376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66377     return 0;
66378   }
66379   arg2 = *argp2;
66380   {
66381     try {
66382       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66383     } catch (std::out_of_range& e) {
66384       {
66385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66386       };
66387     } catch (std::exception& e) {
66388       {
66389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66390       };
66391     } catch (Dali::DaliException e) {
66392       {
66393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66394       };
66395     } catch (...) {
66396       {
66397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66398       };
66399     }
66400   }
66401
66402   jresult = result;
66403   return jresult;
66404 }
66405
66406
66407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66408   unsigned int jresult ;
66409   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66410   Dali::PanGesture arg2 ;
66411   Dali::PanGesture *argp2 ;
66412   bool result;
66413
66414   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66415   argp2 = (Dali::PanGesture *)jarg2;
66416   if (!argp2) {
66417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66418     return 0;
66419   }
66420   arg2 = *argp2;
66421   {
66422     try {
66423       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66424     } catch (std::out_of_range& e) {
66425       {
66426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66427       };
66428     } catch (std::exception& e) {
66429       {
66430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66431       };
66432     } catch (Dali::DaliException e) {
66433       {
66434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66435       };
66436     } catch (...) {
66437       {
66438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66439       };
66440     }
66441   }
66442
66443   jresult = result;
66444   return jresult;
66445 }
66446
66447
66448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66449   unsigned int jresult ;
66450   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66451   Dali::TouchEvent *arg2 = 0 ;
66452   bool result;
66453
66454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66455   arg2 = (Dali::TouchEvent *)jarg2;
66456   if (!arg2) {
66457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66458     return 0;
66459   }
66460   {
66461     try {
66462       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66463     } catch (std::out_of_range& e) {
66464       {
66465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66466       };
66467     } catch (std::exception& e) {
66468       {
66469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66470       };
66471     } catch (Dali::DaliException e) {
66472       {
66473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66474       };
66475     } catch (...) {
66476       {
66477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66478       };
66479     }
66480   }
66481
66482   jresult = result;
66483   return jresult;
66484 }
66485
66486
66487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66488   unsigned int jresult ;
66489   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66490   Dali::TouchEvent *arg2 = 0 ;
66491   bool result;
66492
66493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66494   arg2 = (Dali::TouchEvent *)jarg2;
66495   if (!arg2) {
66496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66497     return 0;
66498   }
66499   {
66500     try {
66501       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66502     } catch (std::out_of_range& e) {
66503       {
66504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66505       };
66506     } catch (std::exception& e) {
66507       {
66508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66509       };
66510     } catch (Dali::DaliException e) {
66511       {
66512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66513       };
66514     } catch (...) {
66515       {
66516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66517       };
66518     }
66519   }
66520
66521   jresult = result;
66522   return jresult;
66523 }
66524
66525
66526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66527   unsigned int jresult ;
66528   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66529   bool arg2 ;
66530   bool result;
66531
66532   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66533   arg2 = jarg2 ? true : false;
66534   {
66535     try {
66536       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66537     } catch (std::out_of_range& e) {
66538       {
66539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66540       };
66541     } catch (std::exception& e) {
66542       {
66543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66544       };
66545     } catch (Dali::DaliException e) {
66546       {
66547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66548       };
66549     } catch (...) {
66550       {
66551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66552       };
66553     }
66554   }
66555
66556   jresult = result;
66557   return jresult;
66558 }
66559
66560
66561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66562   unsigned int jresult ;
66563   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66564   bool arg2 ;
66565   bool result;
66566
66567   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66568   arg2 = jarg2 ? true : false;
66569   {
66570     try {
66571       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66572     } catch (std::out_of_range& e) {
66573       {
66574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66575       };
66576     } catch (std::exception& e) {
66577       {
66578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66579       };
66580     } catch (Dali::DaliException e) {
66581       {
66582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66583       };
66584     } catch (...) {
66585       {
66586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66587       };
66588     }
66589   }
66590
66591   jresult = result;
66592   return jresult;
66593 }
66594
66595
66596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66597   unsigned int jresult ;
66598   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66599   bool result;
66600
66601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66602   {
66603     try {
66604       result = (bool)(arg1)->OnAccessibilityZoom();
66605     } catch (std::out_of_range& e) {
66606       {
66607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66608       };
66609     } catch (std::exception& e) {
66610       {
66611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66612       };
66613     } catch (Dali::DaliException e) {
66614       {
66615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66616       };
66617     } catch (...) {
66618       {
66619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66620       };
66621     }
66622   }
66623
66624   jresult = result;
66625   return jresult;
66626 }
66627
66628
66629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66630   unsigned int jresult ;
66631   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66632   bool result;
66633
66634   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66635   {
66636     try {
66637       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66638     } catch (std::out_of_range& e) {
66639       {
66640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66641       };
66642     } catch (std::exception& e) {
66643       {
66644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66645       };
66646     } catch (Dali::DaliException e) {
66647       {
66648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66649       };
66650     } catch (...) {
66651       {
66652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66653       };
66654     }
66655   }
66656
66657   jresult = result;
66658   return jresult;
66659 }
66660
66661
66662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66663   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66664
66665   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66666   {
66667     try {
66668       (arg1)->OnKeyInputFocusGained();
66669     } catch (std::out_of_range& e) {
66670       {
66671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66672       };
66673     } catch (std::exception& e) {
66674       {
66675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66676       };
66677     } catch (Dali::DaliException e) {
66678       {
66679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66680       };
66681     } catch (...) {
66682       {
66683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66684       };
66685     }
66686   }
66687
66688 }
66689
66690
66691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66692   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66693
66694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66695   {
66696     try {
66697       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66698     } catch (std::out_of_range& e) {
66699       {
66700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66701       };
66702     } catch (std::exception& e) {
66703       {
66704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66705       };
66706     } catch (Dali::DaliException e) {
66707       {
66708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66709       };
66710     } catch (...) {
66711       {
66712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66713       };
66714     }
66715   }
66716
66717 }
66718
66719
66720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66722
66723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66724   {
66725     try {
66726       (arg1)->OnKeyInputFocusLost();
66727     } catch (std::out_of_range& e) {
66728       {
66729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66730       };
66731     } catch (std::exception& e) {
66732       {
66733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66734       };
66735     } catch (Dali::DaliException e) {
66736       {
66737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66738       };
66739     } catch (...) {
66740       {
66741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66742       };
66743     }
66744   }
66745
66746 }
66747
66748
66749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66750   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66751
66752   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66753   {
66754     try {
66755       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66756     } catch (std::out_of_range& e) {
66757       {
66758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66759       };
66760     } catch (std::exception& e) {
66761       {
66762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66763       };
66764     } catch (Dali::DaliException e) {
66765       {
66766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66767       };
66768     } catch (...) {
66769       {
66770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66771       };
66772     }
66773   }
66774
66775 }
66776
66777
66778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66779   void * jresult ;
66780   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66781   Dali::Actor arg2 ;
66782   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66783   bool arg4 ;
66784   Dali::Actor *argp2 ;
66785   Dali::Actor result;
66786
66787   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66788   argp2 = (Dali::Actor *)jarg2;
66789   if (!argp2) {
66790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66791     return 0;
66792   }
66793   arg2 = *argp2;
66794   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66795   arg4 = jarg4 ? true : false;
66796   {
66797     try {
66798       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66799     } catch (std::out_of_range& e) {
66800       {
66801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66802       };
66803     } catch (std::exception& e) {
66804       {
66805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66806       };
66807     } catch (Dali::DaliException e) {
66808       {
66809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66810       };
66811     } catch (...) {
66812       {
66813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66814       };
66815     }
66816   }
66817
66818   jresult = new Dali::Actor((const Dali::Actor &)result);
66819   return jresult;
66820 }
66821
66822
66823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66824   void * jresult ;
66825   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66826   Dali::Actor arg2 ;
66827   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66828   bool arg4 ;
66829   Dali::Actor *argp2 ;
66830   Dali::Actor result;
66831
66832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66833   argp2 = (Dali::Actor *)jarg2;
66834   if (!argp2) {
66835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66836     return 0;
66837   }
66838   arg2 = *argp2;
66839   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66840   arg4 = jarg4 ? true : false;
66841   {
66842     try {
66843       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66844     } catch (std::out_of_range& e) {
66845       {
66846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66847       };
66848     } catch (std::exception& e) {
66849       {
66850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66851       };
66852     } catch (Dali::DaliException e) {
66853       {
66854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66855       };
66856     } catch (...) {
66857       {
66858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66859       };
66860     }
66861   }
66862
66863   jresult = new Dali::Actor((const Dali::Actor &)result);
66864   return jresult;
66865 }
66866
66867
66868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66870   Dali::Actor arg2 ;
66871   Dali::Actor *argp2 ;
66872
66873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66874   argp2 = (Dali::Actor *)jarg2;
66875   if (!argp2) {
66876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66877     return ;
66878   }
66879   arg2 = *argp2;
66880   {
66881     try {
66882       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66883     } catch (std::out_of_range& e) {
66884       {
66885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66886       };
66887     } catch (std::exception& e) {
66888       {
66889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66890       };
66891     } catch (Dali::DaliException e) {
66892       {
66893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66894       };
66895     } catch (...) {
66896       {
66897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66898       };
66899     }
66900   }
66901
66902 }
66903
66904
66905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66906   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66907   Dali::Actor arg2 ;
66908   Dali::Actor *argp2 ;
66909
66910   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66911   argp2 = (Dali::Actor *)jarg2;
66912   if (!argp2) {
66913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66914     return ;
66915   }
66916   arg2 = *argp2;
66917   {
66918     try {
66919       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66920     } catch (std::out_of_range& e) {
66921       {
66922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66923       };
66924     } catch (std::exception& e) {
66925       {
66926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66927       };
66928     } catch (Dali::DaliException e) {
66929       {
66930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66931       };
66932     } catch (...) {
66933       {
66934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66935       };
66936     }
66937   }
66938
66939 }
66940
66941
66942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66943   unsigned int jresult ;
66944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66945   bool result;
66946
66947   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66948   {
66949     try {
66950       result = (bool)(arg1)->OnKeyboardEnter();
66951     } catch (std::out_of_range& e) {
66952       {
66953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66954       };
66955     } catch (std::exception& e) {
66956       {
66957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66958       };
66959     } catch (Dali::DaliException e) {
66960       {
66961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66962       };
66963     } catch (...) {
66964       {
66965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66966       };
66967     }
66968   }
66969
66970   jresult = result;
66971   return jresult;
66972 }
66973
66974
66975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66976   unsigned int jresult ;
66977   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66978   bool result;
66979
66980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66981   {
66982     try {
66983       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66984     } catch (std::out_of_range& e) {
66985       {
66986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66987       };
66988     } catch (std::exception& e) {
66989       {
66990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66991       };
66992     } catch (Dali::DaliException e) {
66993       {
66994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66995       };
66996     } catch (...) {
66997       {
66998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66999       };
67000     }
67001   }
67002
67003   jresult = result;
67004   return jresult;
67005 }
67006
67007
67008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
67009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67010   Dali::PinchGesture *arg2 = 0 ;
67011
67012   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67013   arg2 = (Dali::PinchGesture *)jarg2;
67014   if (!arg2) {
67015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67016     return ;
67017   }
67018   {
67019     try {
67020       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
67021     } catch (std::out_of_range& e) {
67022       {
67023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67024       };
67025     } catch (std::exception& e) {
67026       {
67027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67028       };
67029     } catch (Dali::DaliException e) {
67030       {
67031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67032       };
67033     } catch (...) {
67034       {
67035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67036       };
67037     }
67038   }
67039
67040 }
67041
67042
67043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67044   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67045   Dali::PinchGesture *arg2 = 0 ;
67046
67047   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67048   arg2 = (Dali::PinchGesture *)jarg2;
67049   if (!arg2) {
67050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67051     return ;
67052   }
67053   {
67054     try {
67055       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
67056     } catch (std::out_of_range& e) {
67057       {
67058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67059       };
67060     } catch (std::exception& e) {
67061       {
67062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67063       };
67064     } catch (Dali::DaliException e) {
67065       {
67066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67067       };
67068     } catch (...) {
67069       {
67070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67071       };
67072     }
67073   }
67074
67075 }
67076
67077
67078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
67079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67080   Dali::PanGesture *arg2 = 0 ;
67081
67082   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67083   arg2 = (Dali::PanGesture *)jarg2;
67084   if (!arg2) {
67085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67086     return ;
67087   }
67088   {
67089     try {
67090       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
67091     } catch (std::out_of_range& e) {
67092       {
67093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67094       };
67095     } catch (std::exception& e) {
67096       {
67097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67098       };
67099     } catch (Dali::DaliException e) {
67100       {
67101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67102       };
67103     } catch (...) {
67104       {
67105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67106       };
67107     }
67108   }
67109
67110 }
67111
67112
67113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67115   Dali::PanGesture *arg2 = 0 ;
67116
67117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67118   arg2 = (Dali::PanGesture *)jarg2;
67119   if (!arg2) {
67120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67121     return ;
67122   }
67123   {
67124     try {
67125       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
67126     } catch (std::out_of_range& e) {
67127       {
67128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67129       };
67130     } catch (std::exception& e) {
67131       {
67132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67133       };
67134     } catch (Dali::DaliException e) {
67135       {
67136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67137       };
67138     } catch (...) {
67139       {
67140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67141       };
67142     }
67143   }
67144
67145 }
67146
67147
67148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
67149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67150   Dali::TapGesture *arg2 = 0 ;
67151
67152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67153   arg2 = (Dali::TapGesture *)jarg2;
67154   if (!arg2) {
67155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67156     return ;
67157   }
67158   {
67159     try {
67160       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
67161     } catch (std::out_of_range& e) {
67162       {
67163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67164       };
67165     } catch (std::exception& e) {
67166       {
67167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67168       };
67169     } catch (Dali::DaliException e) {
67170       {
67171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67172       };
67173     } catch (...) {
67174       {
67175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67176       };
67177     }
67178   }
67179
67180 }
67181
67182
67183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67184   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67185   Dali::TapGesture *arg2 = 0 ;
67186
67187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67188   arg2 = (Dali::TapGesture *)jarg2;
67189   if (!arg2) {
67190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67191     return ;
67192   }
67193   {
67194     try {
67195       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
67196     } catch (std::out_of_range& e) {
67197       {
67198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67199       };
67200     } catch (std::exception& e) {
67201       {
67202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67203       };
67204     } catch (Dali::DaliException e) {
67205       {
67206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67207       };
67208     } catch (...) {
67209       {
67210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67211       };
67212     }
67213   }
67214
67215 }
67216
67217
67218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
67219   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67220   Dali::LongPressGesture *arg2 = 0 ;
67221
67222   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67223   arg2 = (Dali::LongPressGesture *)jarg2;
67224   if (!arg2) {
67225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67226     return ;
67227   }
67228   {
67229     try {
67230       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
67231     } catch (std::out_of_range& e) {
67232       {
67233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67234       };
67235     } catch (std::exception& e) {
67236       {
67237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67238       };
67239     } catch (Dali::DaliException e) {
67240       {
67241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67242       };
67243     } catch (...) {
67244       {
67245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67246       };
67247     }
67248   }
67249
67250 }
67251
67252
67253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67255   Dali::LongPressGesture *arg2 = 0 ;
67256
67257   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67258   arg2 = (Dali::LongPressGesture *)jarg2;
67259   if (!arg2) {
67260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67261     return ;
67262   }
67263   {
67264     try {
67265       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
67266     } catch (std::out_of_range& e) {
67267       {
67268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67269       };
67270     } catch (std::exception& e) {
67271       {
67272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67273       };
67274     } catch (Dali::DaliException e) {
67275       {
67276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67277       };
67278     } catch (...) {
67279       {
67280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67281       };
67282     }
67283   }
67284
67285 }
67286
67287
67288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67290   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67291   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67292
67293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67294   arg2 = (Dali::SlotObserver *)jarg2;
67295   arg3 = (Dali::CallbackBase *)jarg3;
67296   {
67297     try {
67298       (arg1)->SignalConnected(arg2,arg3);
67299     } catch (std::out_of_range& e) {
67300       {
67301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67302       };
67303     } catch (std::exception& e) {
67304       {
67305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67306       };
67307     } catch (Dali::DaliException e) {
67308       {
67309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67310       };
67311     } catch (...) {
67312       {
67313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67314       };
67315     }
67316   }
67317
67318 }
67319
67320
67321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67323   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67324   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67325
67326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67327   arg2 = (Dali::SlotObserver *)jarg2;
67328   arg3 = (Dali::CallbackBase *)jarg3;
67329   {
67330     try {
67331       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67332     } catch (std::out_of_range& e) {
67333       {
67334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67335       };
67336     } catch (std::exception& e) {
67337       {
67338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67339       };
67340     } catch (Dali::DaliException e) {
67341       {
67342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67343       };
67344     } catch (...) {
67345       {
67346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67347       };
67348     }
67349   }
67350
67351 }
67352
67353
67354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67355   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67356   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67357   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67358
67359   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67360   arg2 = (Dali::SlotObserver *)jarg2;
67361   arg3 = (Dali::CallbackBase *)jarg3;
67362   {
67363     try {
67364       (arg1)->SignalDisconnected(arg2,arg3);
67365     } catch (std::out_of_range& e) {
67366       {
67367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67368       };
67369     } catch (std::exception& e) {
67370       {
67371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67372       };
67373     } catch (Dali::DaliException e) {
67374       {
67375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67376       };
67377     } catch (...) {
67378       {
67379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67380       };
67381     }
67382   }
67383
67384 }
67385
67386
67387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67388   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67389   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67390   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67391
67392   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67393   arg2 = (Dali::SlotObserver *)jarg2;
67394   arg3 = (Dali::CallbackBase *)jarg3;
67395   {
67396     try {
67397       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67398     } catch (std::out_of_range& e) {
67399       {
67400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67401       };
67402     } catch (std::exception& e) {
67403       {
67404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67405       };
67406     } catch (Dali::DaliException e) {
67407       {
67408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67409       };
67410     } catch (...) {
67411       {
67412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67413       };
67414     }
67415   }
67416
67417 }
67418
67419
67420 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) {
67421   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67422   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67423   if (director) {
67424     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);
67425   }
67426 }
67427
67428
67429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67430   void * jresult ;
67431   Dali::Toolkit::Control *arg1 = 0 ;
67432   Dali::Toolkit::Internal::Control *result = 0 ;
67433
67434   arg1 = (Dali::Toolkit::Control *)jarg1;
67435   if (!arg1) {
67436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67437     return 0;
67438   }
67439   {
67440     try {
67441       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67442     } catch (std::out_of_range& e) {
67443       {
67444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67445       };
67446     } catch (std::exception& e) {
67447       {
67448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67449       };
67450     } catch (Dali::DaliException e) {
67451       {
67452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67453       };
67454     } catch (...) {
67455       {
67456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67457       };
67458     }
67459   }
67460
67461   jresult = (void *)result;
67462   return jresult;
67463 }
67464
67465
67466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67467   int jresult ;
67468   int result;
67469
67470   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67471   jresult = (int)result;
67472   return jresult;
67473 }
67474
67475
67476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67477   int jresult ;
67478   int result;
67479
67480   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67481   jresult = (int)result;
67482   return jresult;
67483 }
67484
67485
67486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67487   int jresult ;
67488   int result;
67489
67490   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67491   jresult = (int)result;
67492   return jresult;
67493 }
67494
67495
67496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67497   int jresult ;
67498   int result;
67499
67500   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67501   jresult = (int)result;
67502   return jresult;
67503 }
67504
67505
67506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67507   int jresult ;
67508   int result;
67509
67510   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67511   jresult = (int)result;
67512   return jresult;
67513 }
67514
67515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67516   int jresult ;
67517   int result;
67518
67519   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67520   jresult = (int)result;
67521   return jresult;
67522 }
67523
67524
67525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67526   int jresult ;
67527   int result;
67528
67529   result = (int)Dali::Toolkit::Control::Property::PADDING;
67530   jresult = (int)result;
67531   return jresult;
67532 }
67533
67534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67535   void * jresult ;
67536   Dali::Toolkit::Control::Property *result = 0 ;
67537
67538   {
67539     try {
67540       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67541     } catch (std::out_of_range& e) {
67542       {
67543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67544       };
67545     } catch (std::exception& e) {
67546       {
67547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67548       };
67549     } catch (Dali::DaliException e) {
67550       {
67551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67552       };
67553     } catch (...) {
67554       {
67555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67556       };
67557     }
67558   }
67559
67560   jresult = (void *)result;
67561   return jresult;
67562 }
67563
67564
67565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67566   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67567
67568   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67569   {
67570     try {
67571       delete arg1;
67572     } catch (std::out_of_range& e) {
67573       {
67574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67575       };
67576     } catch (std::exception& e) {
67577       {
67578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67579       };
67580     } catch (Dali::DaliException e) {
67581       {
67582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67583       };
67584     } catch (...) {
67585       {
67586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67587       };
67588     }
67589   }
67590
67591 }
67592
67593
67594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67595   void * jresult ;
67596   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67597
67598   {
67599     try {
67600       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67601     } catch (std::out_of_range& e) {
67602       {
67603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67604       };
67605     } catch (std::exception& e) {
67606       {
67607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67608       };
67609     } catch (Dali::DaliException e) {
67610       {
67611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67612       };
67613     } catch (...) {
67614       {
67615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67616       };
67617     }
67618   }
67619
67620   jresult = (void *)result;
67621   return jresult;
67622 }
67623
67624
67625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67626   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67627
67628   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67629   {
67630     try {
67631       delete arg1;
67632     } catch (std::out_of_range& e) {
67633       {
67634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67635       };
67636     } catch (std::exception& e) {
67637       {
67638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67639       };
67640     } catch (Dali::DaliException e) {
67641       {
67642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67643       };
67644     } catch (...) {
67645       {
67646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67647       };
67648     }
67649   }
67650
67651 }
67652
67653
67654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67655   void * jresult ;
67656   Dali::Toolkit::Control result;
67657
67658   {
67659     try {
67660       result = Dali::Toolkit::Control::New();
67661     } catch (std::out_of_range& e) {
67662       {
67663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67664       };
67665     } catch (std::exception& e) {
67666       {
67667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67668       };
67669     } catch (Dali::DaliException e) {
67670       {
67671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67672       };
67673     } catch (...) {
67674       {
67675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67676       };
67677     }
67678   }
67679
67680   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67681   return jresult;
67682 }
67683
67684
67685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67686   void * jresult ;
67687   Dali::Toolkit::Control *result = 0 ;
67688
67689   {
67690     try {
67691       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67692     } catch (std::out_of_range& e) {
67693       {
67694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67695       };
67696     } catch (std::exception& e) {
67697       {
67698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67699       };
67700     } catch (Dali::DaliException e) {
67701       {
67702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67703       };
67704     } catch (...) {
67705       {
67706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67707       };
67708     }
67709   }
67710
67711   jresult = (void *)result;
67712   return jresult;
67713 }
67714
67715
67716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67717   void * jresult ;
67718   Dali::Toolkit::Control *arg1 = 0 ;
67719   Dali::Toolkit::Control *result = 0 ;
67720
67721   arg1 = (Dali::Toolkit::Control *)jarg1;
67722   if (!arg1) {
67723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67724     return 0;
67725   }
67726   {
67727     try {
67728       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67729     } catch (std::out_of_range& e) {
67730       {
67731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67732       };
67733     } catch (std::exception& e) {
67734       {
67735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67736       };
67737     } catch (Dali::DaliException e) {
67738       {
67739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67740       };
67741     } catch (...) {
67742       {
67743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67744       };
67745     }
67746   }
67747
67748   jresult = (void *)result;
67749   return jresult;
67750 }
67751
67752
67753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67754   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67755
67756   arg1 = (Dali::Toolkit::Control *)jarg1;
67757   {
67758     try {
67759       delete arg1;
67760     } catch (std::out_of_range& e) {
67761       {
67762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67763       };
67764     } catch (std::exception& e) {
67765       {
67766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67767       };
67768     } catch (Dali::DaliException e) {
67769       {
67770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67771       };
67772     } catch (...) {
67773       {
67774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67775       };
67776     }
67777   }
67778
67779 }
67780
67781
67782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67783   void * jresult ;
67784   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67785   Dali::Toolkit::Control *arg2 = 0 ;
67786   Dali::Toolkit::Control *result = 0 ;
67787
67788   arg1 = (Dali::Toolkit::Control *)jarg1;
67789   arg2 = (Dali::Toolkit::Control *)jarg2;
67790   if (!arg2) {
67791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67792     return 0;
67793   }
67794   {
67795     try {
67796       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67797     } catch (std::out_of_range& e) {
67798       {
67799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67800       };
67801     } catch (std::exception& e) {
67802       {
67803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67804       };
67805     } catch (Dali::DaliException e) {
67806       {
67807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67808       };
67809     } catch (...) {
67810       {
67811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67812       };
67813     }
67814   }
67815
67816   jresult = (void *)result;
67817   return jresult;
67818 }
67819
67820
67821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67822   void * jresult ;
67823   Dali::BaseHandle arg1 ;
67824   Dali::BaseHandle *argp1 ;
67825   Dali::Toolkit::Control result;
67826
67827   argp1 = (Dali::BaseHandle *)jarg1;
67828   if (!argp1) {
67829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67830     return 0;
67831   }
67832   arg1 = *argp1;
67833   {
67834     try {
67835       result = Dali::Toolkit::Control::DownCast(arg1);
67836     } catch (std::out_of_range& e) {
67837       {
67838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67839       };
67840     } catch (std::exception& e) {
67841       {
67842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67843       };
67844     } catch (Dali::DaliException e) {
67845       {
67846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67847       };
67848     } catch (...) {
67849       {
67850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67851       };
67852     }
67853   }
67854
67855   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67856   return jresult;
67857 }
67858
67859
67860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67861   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67862
67863   arg1 = (Dali::Toolkit::Control *)jarg1;
67864   {
67865     try {
67866       (arg1)->SetKeyInputFocus();
67867     } catch (std::out_of_range& e) {
67868       {
67869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67870       };
67871     } catch (std::exception& e) {
67872       {
67873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67874       };
67875     } catch (Dali::DaliException e) {
67876       {
67877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67878       };
67879     } catch (...) {
67880       {
67881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67882       };
67883     }
67884   }
67885
67886 }
67887
67888
67889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67890   unsigned int jresult ;
67891   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67892   bool result;
67893
67894   arg1 = (Dali::Toolkit::Control *)jarg1;
67895   {
67896     try {
67897       result = (bool)(arg1)->HasKeyInputFocus();
67898     } catch (std::out_of_range& e) {
67899       {
67900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67901       };
67902     } catch (std::exception& e) {
67903       {
67904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67905       };
67906     } catch (Dali::DaliException e) {
67907       {
67908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67909       };
67910     } catch (...) {
67911       {
67912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67913       };
67914     }
67915   }
67916
67917   jresult = result;
67918   return jresult;
67919 }
67920
67921
67922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67923   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67924
67925   arg1 = (Dali::Toolkit::Control *)jarg1;
67926   {
67927     try {
67928       (arg1)->ClearKeyInputFocus();
67929     } catch (std::out_of_range& e) {
67930       {
67931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67932       };
67933     } catch (std::exception& e) {
67934       {
67935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67936       };
67937     } catch (Dali::DaliException e) {
67938       {
67939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67940       };
67941     } catch (...) {
67942       {
67943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67944       };
67945     }
67946   }
67947
67948 }
67949
67950
67951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67952   void * jresult ;
67953   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67954   Dali::PinchGestureDetector result;
67955
67956   arg1 = (Dali::Toolkit::Control *)jarg1;
67957   {
67958     try {
67959       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67960     } catch (std::out_of_range& e) {
67961       {
67962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67963       };
67964     } catch (std::exception& e) {
67965       {
67966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67967       };
67968     } catch (Dali::DaliException e) {
67969       {
67970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67971       };
67972     } catch (...) {
67973       {
67974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67975       };
67976     }
67977   }
67978
67979   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67980   return jresult;
67981 }
67982
67983
67984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67985   void * jresult ;
67986   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67987   Dali::PanGestureDetector result;
67988
67989   arg1 = (Dali::Toolkit::Control *)jarg1;
67990   {
67991     try {
67992       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67993     } catch (std::out_of_range& e) {
67994       {
67995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67996       };
67997     } catch (std::exception& e) {
67998       {
67999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68000       };
68001     } catch (Dali::DaliException e) {
68002       {
68003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68004       };
68005     } catch (...) {
68006       {
68007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68008       };
68009     }
68010   }
68011
68012   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
68013   return jresult;
68014 }
68015
68016
68017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
68018   void * jresult ;
68019   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68020   Dali::TapGestureDetector result;
68021
68022   arg1 = (Dali::Toolkit::Control *)jarg1;
68023   {
68024     try {
68025       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
68026     } catch (std::out_of_range& e) {
68027       {
68028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68029       };
68030     } catch (std::exception& e) {
68031       {
68032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68033       };
68034     } catch (Dali::DaliException e) {
68035       {
68036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68037       };
68038     } catch (...) {
68039       {
68040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68041       };
68042     }
68043   }
68044
68045   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
68046   return jresult;
68047 }
68048
68049
68050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
68051   void * jresult ;
68052   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68053   Dali::LongPressGestureDetector result;
68054
68055   arg1 = (Dali::Toolkit::Control *)jarg1;
68056   {
68057     try {
68058       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
68059     } catch (std::out_of_range& e) {
68060       {
68061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68062       };
68063     } catch (std::exception& e) {
68064       {
68065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68066       };
68067     } catch (Dali::DaliException e) {
68068       {
68069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68070       };
68071     } catch (...) {
68072       {
68073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68074       };
68075     }
68076   }
68077
68078   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
68079   return jresult;
68080 }
68081
68082
68083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
68084   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68085   std::string *arg2 = 0 ;
68086
68087   arg1 = (Dali::Toolkit::Control *)jarg1;
68088   if (!jarg2) {
68089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68090     return ;
68091   }
68092   std::string arg2_str(jarg2);
68093   arg2 = &arg2_str;
68094   {
68095     try {
68096       (arg1)->SetStyleName((std::string const &)*arg2);
68097     } catch (std::out_of_range& e) {
68098       {
68099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68100       };
68101     } catch (std::exception& e) {
68102       {
68103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68104       };
68105     } catch (Dali::DaliException e) {
68106       {
68107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68108       };
68109     } catch (...) {
68110       {
68111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68112       };
68113     }
68114   }
68115
68116
68117   //argout typemap for const std::string&
68118
68119 }
68120
68121
68122 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
68123   char * jresult ;
68124   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68125   std::string *result = 0 ;
68126
68127   arg1 = (Dali::Toolkit::Control *)jarg1;
68128   {
68129     try {
68130       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
68131     } catch (std::out_of_range& e) {
68132       {
68133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68134       };
68135     } catch (std::exception& e) {
68136       {
68137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68138       };
68139     } catch (Dali::DaliException e) {
68140       {
68141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68142       };
68143     } catch (...) {
68144       {
68145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68146       };
68147     }
68148   }
68149
68150   jresult = SWIG_csharp_string_callback(result->c_str());
68151   return jresult;
68152 }
68153
68154
68155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
68156   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68157   Dali::Vector4 *arg2 = 0 ;
68158
68159   arg1 = (Dali::Toolkit::Control *)jarg1;
68160   arg2 = (Dali::Vector4 *)jarg2;
68161   if (!arg2) {
68162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68163     return ;
68164   }
68165   {
68166     try {
68167       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
68168     } catch (std::out_of_range& e) {
68169       {
68170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68171       };
68172     } catch (std::exception& e) {
68173       {
68174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68175       };
68176     } catch (Dali::DaliException e) {
68177       {
68178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68179       };
68180     } catch (...) {
68181       {
68182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68183       };
68184     }
68185   }
68186
68187 }
68188
68189
68190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
68191   void * jresult ;
68192   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68193   Dali::Vector4 result;
68194
68195   arg1 = (Dali::Toolkit::Control *)jarg1;
68196   {
68197     try {
68198       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
68199     } catch (std::out_of_range& e) {
68200       {
68201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68202       };
68203     } catch (std::exception& e) {
68204       {
68205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68206       };
68207     } catch (Dali::DaliException e) {
68208       {
68209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68210       };
68211     } catch (...) {
68212       {
68213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68214       };
68215     }
68216   }
68217
68218   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68219   return jresult;
68220 }
68221
68222
68223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
68224   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68225   Dali::Image arg2 ;
68226   Dali::Image *argp2 ;
68227
68228   arg1 = (Dali::Toolkit::Control *)jarg1;
68229   argp2 = (Dali::Image *)jarg2;
68230   if (!argp2) {
68231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
68232     return ;
68233   }
68234   arg2 = *argp2;
68235   {
68236     try {
68237       (arg1)->SetBackgroundImage(arg2);
68238     } catch (std::out_of_range& e) {
68239       {
68240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68241       };
68242     } catch (std::exception& e) {
68243       {
68244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68245       };
68246     } catch (Dali::DaliException e) {
68247       {
68248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68249       };
68250     } catch (...) {
68251       {
68252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68253       };
68254     }
68255   }
68256
68257 }
68258
68259
68260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
68261   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68262
68263   arg1 = (Dali::Toolkit::Control *)jarg1;
68264   {
68265     try {
68266       (arg1)->ClearBackground();
68267     } catch (std::out_of_range& e) {
68268       {
68269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68270       };
68271     } catch (std::exception& e) {
68272       {
68273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68274       };
68275     } catch (Dali::DaliException e) {
68276       {
68277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68278       };
68279     } catch (...) {
68280       {
68281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68282       };
68283     }
68284   }
68285
68286 }
68287
68288
68289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68290   void * jresult ;
68291   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68292   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68293
68294   arg1 = (Dali::Toolkit::Control *)jarg1;
68295   {
68296     try {
68297       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68298     } catch (std::out_of_range& e) {
68299       {
68300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68301       };
68302     } catch (std::exception& e) {
68303       {
68304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68305       };
68306     } catch (Dali::DaliException e) {
68307       {
68308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68309       };
68310     } catch (...) {
68311       {
68312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68313       };
68314     }
68315   }
68316
68317   jresult = (void *)result;
68318   return jresult;
68319 }
68320
68321
68322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68323   void * jresult ;
68324   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68325   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68326
68327   arg1 = (Dali::Toolkit::Control *)jarg1;
68328   {
68329     try {
68330       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68331     } catch (std::out_of_range& e) {
68332       {
68333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68334       };
68335     } catch (std::exception& e) {
68336       {
68337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68338       };
68339     } catch (Dali::DaliException e) {
68340       {
68341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68342       };
68343     } catch (...) {
68344       {
68345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68346       };
68347     }
68348   }
68349
68350   jresult = (void *)result;
68351   return jresult;
68352 }
68353
68354
68355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68356   void * jresult ;
68357   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68358   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68359
68360   arg1 = (Dali::Toolkit::Control *)jarg1;
68361   {
68362     try {
68363       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68364     } catch (std::out_of_range& e) {
68365       {
68366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68367       };
68368     } catch (std::exception& e) {
68369       {
68370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68371       };
68372     } catch (Dali::DaliException e) {
68373       {
68374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68375       };
68376     } catch (...) {
68377       {
68378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68379       };
68380     }
68381   }
68382
68383   jresult = (void *)result;
68384   return jresult;
68385 }
68386
68387
68388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68389   void * jresult ;
68390   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68391   Dali::Toolkit::Control *result = 0 ;
68392
68393   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68394   if (!arg1) {
68395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68396     return 0;
68397   }
68398   {
68399     try {
68400       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68401     } catch (std::out_of_range& e) {
68402       {
68403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68404       };
68405     } catch (std::exception& e) {
68406       {
68407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68408       };
68409     } catch (Dali::DaliException e) {
68410       {
68411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68412       };
68413     } catch (...) {
68414       {
68415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68416       };
68417     }
68418   }
68419
68420   jresult = (void *)result;
68421   return jresult;
68422 }
68423
68424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68425 {
68426   int jresult;
68427   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68428   arg1 = (Dali::Toolkit::Control *)jarg1;
68429
68430   if (!arg1) {
68431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68432     return 0;
68433   }
68434
68435   Dali::Property::Index arg2 = 0 ;
68436   arg2 = (Dali::Property::Index)jarg2;
68437
68438   Toolkit::Visual::ResourceStatus result;
68439   {
68440     try {
68441       result = arg1->GetVisualResourceStatus(arg2);
68442     } catch (std::out_of_range& e) {
68443       {
68444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68445       };
68446     } catch (std::exception& e) {
68447       {
68448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68449       };
68450     } catch (...) {
68451       {
68452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68453       };
68454     }
68455   }
68456   jresult = (int)(result);
68457   return jresult;
68458 }
68459
68460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68461 {
68462   void * jresult;
68463   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68464   arg1 = (Dali::Toolkit::Control *)jarg1;
68465
68466   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68467
68468   Dali::Toolkit::TransitionData *arg2 = 0 ;
68469   Dali::Animation result;
68470
68471   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68472   if (!arg2) {
68473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68474     return 0;
68475   }
68476   {
68477     try {
68478       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68479     } catch (std::out_of_range& e) {
68480       {
68481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68482       };
68483     } catch (std::exception& e) {
68484       {
68485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68486       };
68487     } catch (Dali::DaliException e) {
68488       {
68489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68490       };
68491     } catch (...) {
68492       {
68493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68494       };
68495     }
68496   }
68497
68498   jresult = new Dali::Animation((const Dali::Animation &)result);
68499   return jresult;
68500 }
68501
68502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68503 {
68504   Dali::Toolkit::Control arg1;
68505   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68506
68507   if (!argp1) {
68508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68509   }
68510   arg1 = *argp1;
68511
68512   Dali::Property::Index arg2 = 0 ;
68513   arg2 = (Dali::Property::Index)jarg2;
68514
68515   Dali::Property::Index arg3 = 0 ;
68516   arg3 = (Dali::Property::Index)jarg3;
68517
68518   Dali::Property::Value arg4;
68519   arg4 = (Dali::Property::Value *)jarg4;
68520
68521   {
68522     try {
68523       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68524     } catch (std::out_of_range& e) {
68525       {
68526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68527       };
68528     } catch (std::exception& e) {
68529       {
68530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68531       };
68532     } catch (...) {
68533       {
68534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68535       };
68536     }
68537   }
68538
68539
68540 }
68541
68542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68543   void * jresult ;
68544   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68545   Dali::Toolkit::LayoutItem result;
68546
68547   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68548   if (!arg1) {
68549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68550     return 0;
68551   }
68552   {
68553     try {
68554       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68555     } catch (std::out_of_range& e) {
68556       {
68557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68558       };
68559     } catch (std::exception& e) {
68560       {
68561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68562       };
68563     } catch (...) {
68564       {
68565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68566       };
68567     }
68568   }
68569   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68570   return jresult;
68571 }
68572
68573
68574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68575   void * jresult ;
68576   Dali::Toolkit::Control arg1 ;
68577   Dali::Toolkit::Control *argp1 ;
68578   Dali::Toolkit::LayoutItem result;
68579
68580   argp1 = (Dali::Toolkit::Control *)jarg1;
68581   if (!argp1) {
68582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68583     return 0;
68584   }
68585   arg1 = *argp1;
68586   {
68587     try {
68588       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68589     } catch (std::out_of_range& e) {
68590       {
68591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68592       };
68593     } catch (std::exception& e) {
68594       {
68595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68596       };
68597     } catch (...) {
68598       {
68599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68600       };
68601     }
68602   }
68603   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68604   return jresult;
68605 }
68606
68607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68608   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68609   Dali::Toolkit::LayoutItem arg2 ;
68610   Dali::Toolkit::LayoutItem *argp2 ;
68611
68612   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68613   if (!arg1) {
68614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68615     return ;
68616   }
68617   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68618   if (!argp2) {
68619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68620     return ;
68621   }
68622   arg2 = *argp2;
68623   {
68624     try {
68625       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68626     } catch (std::out_of_range& e) {
68627       {
68628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68629       };
68630     } catch (std::exception& e) {
68631       {
68632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68633       };
68634     } catch (...) {
68635       {
68636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68637       };
68638     }
68639   }
68640 }
68641
68642
68643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68644   Dali::Toolkit::Control arg1 ;
68645   Dali::Toolkit::LayoutItem arg2 ;
68646   Dali::Toolkit::Control *argp1 ;
68647   Dali::Toolkit::LayoutItem *argp2 ;
68648
68649   argp1 = (Dali::Toolkit::Control *)jarg1;
68650   if (!argp1) {
68651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68652     return ;
68653   }
68654   arg1 = *argp1;
68655   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68656   if (!argp2) {
68657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68658     return ;
68659   }
68660   arg2 = *argp2;
68661   {
68662     try {
68663       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68664     } catch (std::out_of_range& e) {
68665       {
68666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68667       };
68668     } catch (std::exception& e) {
68669       {
68670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68671       };
68672     } catch (...) {
68673       {
68674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68675       };
68676     }
68677   }
68678 }
68679
68680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayoutingRequired(void * jarg1, bool jarg2) {
68681   Dali::Toolkit::Control *arg1 = 0 ;
68682
68683   arg1 = (Dali::Toolkit::Control *)jarg1;
68684   if (!arg1) {
68685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68686     return ;
68687   }
68688
68689   {
68690     try {
68691       Dali::Toolkit::DevelControl::SetLayoutingRequired(*arg1,jarg2);
68692     } catch (std::out_of_range& e) {
68693       {
68694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68695       };
68696     } catch (std::exception& e) {
68697       {
68698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68699       };
68700     } catch (...) {
68701       {
68702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68703       };
68704     }
68705   }
68706 }
68707
68708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_IsLayoutingRequired(void * jarg1) {
68709   unsigned int jresult ;
68710   Dali::Toolkit::Control *arg1 = 0 ;
68711   bool result;
68712
68713   arg1 = (Dali::Toolkit::Control *)jarg1;
68714   if (!arg1) {
68715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68716     return 0;
68717   }
68718   {
68719     try {
68720       result = (bool)DevelControl::IsLayoutingRequired( *arg1 );
68721     } catch (std::out_of_range& e) {
68722       {
68723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68724       };
68725     } catch (std::exception& e) {
68726       {
68727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68728       };
68729     } catch (Dali::DaliException e) {
68730       {
68731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68732       };
68733     } catch (...) {
68734       {
68735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68736       };
68737     }
68738   }
68739
68740   jresult = result;
68741   return jresult;
68742 }
68743
68744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68745   void * jresult ;
68746   Dali::Toolkit::Control *arg1 = 0 ;
68747   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68748
68749   arg1 = (Dali::Toolkit::Control *)jarg1;
68750   if (!arg1) {
68751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68752     return 0;
68753   }
68754   {
68755     try {
68756       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68757     } catch (std::out_of_range& e) {
68758       {
68759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68760       };
68761     } catch (std::exception& e) {
68762       {
68763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68764       };
68765     } catch (Dali::DaliException e) {
68766       {
68767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68768       };
68769     } catch (...) {
68770       {
68771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68772       };
68773     }
68774   }
68775
68776   jresult = (void *)result;
68777   return jresult;
68778 }
68779
68780
68781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68782   unsigned int jresult ;
68783   Dali::Toolkit::Control *arg1 = 0 ;
68784   bool result;
68785
68786   arg1 = (Dali::Toolkit::Control *)jarg1;
68787   if (!arg1) {
68788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68789     return 0;
68790   }
68791   {
68792     try {
68793       result = (bool)arg1->IsResourceReady();
68794     } catch (std::out_of_range& e) {
68795       {
68796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68797       };
68798     } catch (std::exception& e) {
68799       {
68800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68801       };
68802     } catch (Dali::DaliException e) {
68803       {
68804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68805       };
68806     } catch (...) {
68807       {
68808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68809       };
68810     }
68811   }
68812
68813   jresult = result;
68814   return jresult;
68815 }
68816
68817
68818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68819   void * jresult ;
68820   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68821
68822   {
68823     try {
68824       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68825     } catch (std::out_of_range& e) {
68826       {
68827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68828       };
68829     } catch (std::exception& e) {
68830       {
68831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68832       };
68833     } catch (Dali::DaliException e) {
68834       {
68835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68836       };
68837     } catch (...) {
68838       {
68839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68840       };
68841     }
68842   }
68843
68844   jresult = (void *)result;
68845   return jresult;
68846 }
68847
68848
68849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68850   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68851
68852   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68853   {
68854     try {
68855       delete arg1;
68856     } catch (std::out_of_range& e) {
68857       {
68858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68859       };
68860     } catch (std::exception& e) {
68861       {
68862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68863       };
68864     } catch (Dali::DaliException e) {
68865       {
68866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68867       };
68868     } catch (...) {
68869       {
68870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68871       };
68872     }
68873   }
68874
68875 }
68876
68877
68878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68879   void * jresult ;
68880   Dali::Toolkit::KeyInputFocusManager result;
68881
68882   {
68883     try {
68884       result = Dali::Toolkit::KeyInputFocusManager::Get();
68885     } catch (std::out_of_range& e) {
68886       {
68887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68888       };
68889     } catch (std::exception& e) {
68890       {
68891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68892       };
68893     } catch (Dali::DaliException e) {
68894       {
68895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68896       };
68897     } catch (...) {
68898       {
68899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68900       };
68901     }
68902   }
68903
68904   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68905   return jresult;
68906 }
68907
68908
68909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68910   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68911   Dali::Toolkit::Control arg2 ;
68912   Dali::Toolkit::Control *argp2 ;
68913
68914   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68915   argp2 = (Dali::Toolkit::Control *)jarg2;
68916   if (!argp2) {
68917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68918     return ;
68919   }
68920   arg2 = *argp2;
68921   {
68922     try {
68923       (arg1)->SetFocus(arg2);
68924     } catch (std::out_of_range& e) {
68925       {
68926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68927       };
68928     } catch (std::exception& e) {
68929       {
68930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68931       };
68932     } catch (Dali::DaliException e) {
68933       {
68934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68935       };
68936     } catch (...) {
68937       {
68938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68939       };
68940     }
68941   }
68942
68943 }
68944
68945
68946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68947   void * jresult ;
68948   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68949   Dali::Toolkit::Control result;
68950
68951   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68952   {
68953     try {
68954       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68955     } catch (std::out_of_range& e) {
68956       {
68957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68958       };
68959     } catch (std::exception& e) {
68960       {
68961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68962       };
68963     } catch (Dali::DaliException e) {
68964       {
68965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68966       };
68967     } catch (...) {
68968       {
68969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68970       };
68971     }
68972   }
68973
68974   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68975   return jresult;
68976 }
68977
68978
68979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68980   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68981   Dali::Toolkit::Control arg2 ;
68982   Dali::Toolkit::Control *argp2 ;
68983
68984   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68985   argp2 = (Dali::Toolkit::Control *)jarg2;
68986   if (!argp2) {
68987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68988     return ;
68989   }
68990   arg2 = *argp2;
68991   {
68992     try {
68993       (arg1)->RemoveFocus(arg2);
68994     } catch (std::out_of_range& e) {
68995       {
68996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68997       };
68998     } catch (std::exception& e) {
68999       {
69000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69001       };
69002     } catch (Dali::DaliException e) {
69003       {
69004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69005       };
69006     } catch (...) {
69007       {
69008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69009       };
69010     }
69011   }
69012
69013 }
69014
69015
69016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
69017   void * jresult ;
69018   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
69019   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
69020
69021   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
69022   {
69023     try {
69024       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
69025     } catch (std::out_of_range& e) {
69026       {
69027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69028       };
69029     } catch (std::exception& e) {
69030       {
69031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69032       };
69033     } catch (Dali::DaliException e) {
69034       {
69035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69036       };
69037     } catch (...) {
69038       {
69039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69040       };
69041     }
69042   }
69043
69044   jresult = (void *)result;
69045   return jresult;
69046 }
69047
69048
69049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
69050   void * jresult ;
69051   Dali::Toolkit::Alignment::Padding *result = 0 ;
69052
69053   {
69054     try {
69055       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
69056     } catch (std::out_of_range& e) {
69057       {
69058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69059       };
69060     } catch (std::exception& e) {
69061       {
69062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69063       };
69064     } catch (Dali::DaliException e) {
69065       {
69066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69067       };
69068     } catch (...) {
69069       {
69070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69071       };
69072     }
69073   }
69074
69075   jresult = (void *)result;
69076   return jresult;
69077 }
69078
69079
69080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
69081   void * jresult ;
69082   float arg1 ;
69083   float arg2 ;
69084   float arg3 ;
69085   float arg4 ;
69086   Dali::Toolkit::Alignment::Padding *result = 0 ;
69087
69088   arg1 = (float)jarg1;
69089   arg2 = (float)jarg2;
69090   arg3 = (float)jarg3;
69091   arg4 = (float)jarg4;
69092   {
69093     try {
69094       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
69095     } catch (std::out_of_range& e) {
69096       {
69097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69098       };
69099     } catch (std::exception& e) {
69100       {
69101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69102       };
69103     } catch (Dali::DaliException e) {
69104       {
69105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69106       };
69107     } catch (...) {
69108       {
69109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69110       };
69111     }
69112   }
69113
69114   jresult = (void *)result;
69115   return jresult;
69116 }
69117
69118
69119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
69120   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69121   float arg2 ;
69122
69123   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69124   arg2 = (float)jarg2;
69125   if (arg1) (arg1)->left = arg2;
69126 }
69127
69128
69129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
69130   float jresult ;
69131   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69132   float result;
69133
69134   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69135   result = (float) ((arg1)->left);
69136   jresult = result;
69137   return jresult;
69138 }
69139
69140
69141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
69142   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69143   float arg2 ;
69144
69145   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69146   arg2 = (float)jarg2;
69147   if (arg1) (arg1)->right = arg2;
69148 }
69149
69150
69151 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69152   float jresult ;
69153   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69154   float result;
69155
69156   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69157   result = (float) ((arg1)->right);
69158   jresult = result;
69159   return jresult;
69160 }
69161
69162
69163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69164   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69165   float arg2 ;
69166
69167   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69168   arg2 = (float)jarg2;
69169   if (arg1) (arg1)->top = arg2;
69170 }
69171
69172
69173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69174   float jresult ;
69175   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69176   float result;
69177
69178   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69179   result = (float) ((arg1)->top);
69180   jresult = result;
69181   return jresult;
69182 }
69183
69184
69185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69186   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69187   float arg2 ;
69188
69189   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69190   arg2 = (float)jarg2;
69191   if (arg1) (arg1)->bottom = arg2;
69192 }
69193
69194
69195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69196   float jresult ;
69197   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69198   float result;
69199
69200   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69201   result = (float) ((arg1)->bottom);
69202   jresult = result;
69203   return jresult;
69204 }
69205
69206
69207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69208   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69209
69210   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69211   {
69212     try {
69213       delete arg1;
69214     } catch (std::out_of_range& e) {
69215       {
69216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69217       };
69218     } catch (std::exception& e) {
69219       {
69220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69221       };
69222     } catch (Dali::DaliException e) {
69223       {
69224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69225       };
69226     } catch (...) {
69227       {
69228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69229       };
69230     }
69231   }
69232
69233 }
69234
69235
69236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69237   void * jresult ;
69238   Dali::Toolkit::Alignment *result = 0 ;
69239
69240   {
69241     try {
69242       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69243     } catch (std::out_of_range& e) {
69244       {
69245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69246       };
69247     } catch (std::exception& e) {
69248       {
69249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69250       };
69251     } catch (Dali::DaliException e) {
69252       {
69253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69254       };
69255     } catch (...) {
69256       {
69257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69258       };
69259     }
69260   }
69261
69262   jresult = (void *)result;
69263   return jresult;
69264 }
69265
69266
69267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69268   void * jresult ;
69269   Dali::Toolkit::Alignment::Type arg1 ;
69270   Dali::Toolkit::Alignment::Type arg2 ;
69271   Dali::Toolkit::Alignment result;
69272
69273   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69274   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69275   {
69276     try {
69277       result = Dali::Toolkit::Alignment::New(arg1,arg2);
69278     } catch (std::out_of_range& e) {
69279       {
69280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69281       };
69282     } catch (std::exception& e) {
69283       {
69284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69285       };
69286     } catch (Dali::DaliException e) {
69287       {
69288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69289       };
69290     } catch (...) {
69291       {
69292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69293       };
69294     }
69295   }
69296
69297   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69298   return jresult;
69299 }
69300
69301
69302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69303   void * jresult ;
69304   Dali::Toolkit::Alignment::Type arg1 ;
69305   Dali::Toolkit::Alignment result;
69306
69307   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69308   {
69309     try {
69310       result = Dali::Toolkit::Alignment::New(arg1);
69311     } catch (std::out_of_range& e) {
69312       {
69313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69314       };
69315     } catch (std::exception& e) {
69316       {
69317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69318       };
69319     } catch (Dali::DaliException e) {
69320       {
69321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69322       };
69323     } catch (...) {
69324       {
69325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69326       };
69327     }
69328   }
69329
69330   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69331   return jresult;
69332 }
69333
69334
69335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69336   void * jresult ;
69337   Dali::Toolkit::Alignment result;
69338
69339   {
69340     try {
69341       result = Dali::Toolkit::Alignment::New();
69342     } catch (std::out_of_range& e) {
69343       {
69344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69345       };
69346     } catch (std::exception& e) {
69347       {
69348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69349       };
69350     } catch (Dali::DaliException e) {
69351       {
69352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69353       };
69354     } catch (...) {
69355       {
69356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69357       };
69358     }
69359   }
69360
69361   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69362   return jresult;
69363 }
69364
69365
69366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69367   void * jresult ;
69368   Dali::Toolkit::Alignment *arg1 = 0 ;
69369   Dali::Toolkit::Alignment *result = 0 ;
69370
69371   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69372   if (!arg1) {
69373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69374     return 0;
69375   }
69376   {
69377     try {
69378       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69379     } catch (std::out_of_range& e) {
69380       {
69381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69382       };
69383     } catch (std::exception& e) {
69384       {
69385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69386       };
69387     } catch (Dali::DaliException e) {
69388       {
69389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69390       };
69391     } catch (...) {
69392       {
69393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69394       };
69395     }
69396   }
69397
69398   jresult = (void *)result;
69399   return jresult;
69400 }
69401
69402
69403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69404   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69405
69406   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69407   {
69408     try {
69409       delete arg1;
69410     } catch (std::out_of_range& e) {
69411       {
69412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69413       };
69414     } catch (std::exception& e) {
69415       {
69416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69417       };
69418     } catch (Dali::DaliException e) {
69419       {
69420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69421       };
69422     } catch (...) {
69423       {
69424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69425       };
69426     }
69427   }
69428
69429 }
69430
69431
69432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69433   void * jresult ;
69434   Dali::BaseHandle arg1 ;
69435   Dali::BaseHandle *argp1 ;
69436   Dali::Toolkit::Alignment result;
69437
69438   argp1 = (Dali::BaseHandle *)jarg1;
69439   if (!argp1) {
69440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69441     return 0;
69442   }
69443   arg1 = *argp1;
69444   {
69445     try {
69446       result = Dali::Toolkit::Alignment::DownCast(arg1);
69447     } catch (std::out_of_range& e) {
69448       {
69449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69450       };
69451     } catch (std::exception& e) {
69452       {
69453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69454       };
69455     } catch (Dali::DaliException e) {
69456       {
69457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69458       };
69459     } catch (...) {
69460       {
69461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69462       };
69463     }
69464   }
69465
69466   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69467   return jresult;
69468 }
69469
69470
69471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69472   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69473   Dali::Toolkit::Alignment::Type arg2 ;
69474
69475   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69476   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69477   {
69478     try {
69479       (arg1)->SetAlignmentType(arg2);
69480     } catch (std::out_of_range& e) {
69481       {
69482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69483       };
69484     } catch (std::exception& e) {
69485       {
69486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69487       };
69488     } catch (Dali::DaliException e) {
69489       {
69490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69491       };
69492     } catch (...) {
69493       {
69494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69495       };
69496     }
69497   }
69498
69499 }
69500
69501
69502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69503   int jresult ;
69504   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69505   Dali::Toolkit::Alignment::Type result;
69506
69507   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69508   {
69509     try {
69510       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69511     } catch (std::out_of_range& e) {
69512       {
69513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69514       };
69515     } catch (std::exception& e) {
69516       {
69517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69518       };
69519     } catch (Dali::DaliException e) {
69520       {
69521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69522       };
69523     } catch (...) {
69524       {
69525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69526       };
69527     }
69528   }
69529
69530   jresult = (int)result;
69531   return jresult;
69532 }
69533
69534
69535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69536   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69537   Dali::Toolkit::Alignment::Scaling arg2 ;
69538
69539   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69540   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69541   {
69542     try {
69543       (arg1)->SetScaling(arg2);
69544     } catch (std::out_of_range& e) {
69545       {
69546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69547       };
69548     } catch (std::exception& e) {
69549       {
69550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69551       };
69552     } catch (Dali::DaliException e) {
69553       {
69554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69555       };
69556     } catch (...) {
69557       {
69558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69559       };
69560     }
69561   }
69562
69563 }
69564
69565
69566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69567   int jresult ;
69568   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69569   Dali::Toolkit::Alignment::Scaling result;
69570
69571   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69572   {
69573     try {
69574       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69575     } catch (std::out_of_range& e) {
69576       {
69577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69578       };
69579     } catch (std::exception& e) {
69580       {
69581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69582       };
69583     } catch (Dali::DaliException e) {
69584       {
69585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69586       };
69587     } catch (...) {
69588       {
69589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69590       };
69591     }
69592   }
69593
69594   jresult = (int)result;
69595   return jresult;
69596 }
69597
69598
69599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69600   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69601   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69602
69603   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69604   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69605   if (!arg2) {
69606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69607     return ;
69608   }
69609   {
69610     try {
69611       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69612     } catch (std::out_of_range& e) {
69613       {
69614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69615       };
69616     } catch (std::exception& e) {
69617       {
69618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69619       };
69620     } catch (Dali::DaliException e) {
69621       {
69622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69623       };
69624     } catch (...) {
69625       {
69626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69627       };
69628     }
69629   }
69630
69631 }
69632
69633
69634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69635   void * jresult ;
69636   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69637   Dali::Toolkit::Alignment::Padding *result = 0 ;
69638
69639   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69640   {
69641     try {
69642       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69643     } catch (std::out_of_range& e) {
69644       {
69645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69646       };
69647     } catch (std::exception& e) {
69648       {
69649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69650       };
69651     } catch (Dali::DaliException e) {
69652       {
69653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69654       };
69655     } catch (...) {
69656       {
69657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69658       };
69659     }
69660   }
69661
69662   jresult = (void *)result;
69663   return jresult;
69664 }
69665
69666
69667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69668   void * jresult ;
69669   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69670   Dali::Toolkit::Alignment *arg2 = 0 ;
69671   Dali::Toolkit::Alignment *result = 0 ;
69672
69673   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69674   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69675   if (!arg2) {
69676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69677     return 0;
69678   }
69679   {
69680     try {
69681       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69682     } catch (std::out_of_range& e) {
69683       {
69684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69685       };
69686     } catch (std::exception& e) {
69687       {
69688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69689       };
69690     } catch (Dali::DaliException e) {
69691       {
69692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69693       };
69694     } catch (...) {
69695       {
69696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69697       };
69698     }
69699   }
69700
69701   jresult = (void *)result;
69702   return jresult;
69703 }
69704
69705
69706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69707   int jresult ;
69708   int result;
69709
69710   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69711   jresult = (int)result;
69712   return jresult;
69713 }
69714
69715
69716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69717   int jresult ;
69718   int result;
69719
69720   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69721   jresult = (int)result;
69722   return jresult;
69723 }
69724
69725
69726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69727   int jresult ;
69728   int result;
69729
69730   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69731   jresult = (int)result;
69732   return jresult;
69733 }
69734
69735
69736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69737   int jresult ;
69738   int result;
69739
69740   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69741   jresult = (int)result;
69742   return jresult;
69743 }
69744
69745
69746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69747   int jresult ;
69748   int result;
69749
69750   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69751   jresult = (int)result;
69752   return jresult;
69753 }
69754
69755
69756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69757   int jresult ;
69758   int result;
69759
69760   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69761   jresult = (int)result;
69762   return jresult;
69763 }
69764
69765
69766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69767   int jresult ;
69768   int result;
69769
69770   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69771   jresult = (int)result;
69772   return jresult;
69773 }
69774
69775
69776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69777   int jresult ;
69778   int result;
69779
69780   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69781   jresult = (int)result;
69782   return jresult;
69783 }
69784
69785
69786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69787   int jresult ;
69788   int result;
69789
69790   result = (int)Dali::Toolkit::Button::Property::LABEL;
69791   jresult = (int)result;
69792   return jresult;
69793 }
69794
69795
69796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69797   int jresult ;
69798   int result;
69799
69800   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69801   jresult = (int)result;
69802   return jresult;
69803 }
69804
69805
69806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69807   void * jresult ;
69808   Dali::Toolkit::Button::Property *result = 0 ;
69809
69810   {
69811     try {
69812       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69813     } catch (std::out_of_range& e) {
69814       {
69815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69816       };
69817     } catch (std::exception& e) {
69818       {
69819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69820       };
69821     } catch (Dali::DaliException e) {
69822       {
69823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69824       };
69825     } catch (...) {
69826       {
69827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69828       };
69829     }
69830   }
69831
69832   jresult = (void *)result;
69833   return jresult;
69834 }
69835
69836
69837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69838   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69839
69840   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69841   {
69842     try {
69843       delete arg1;
69844     } catch (std::out_of_range& e) {
69845       {
69846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69847       };
69848     } catch (std::exception& e) {
69849       {
69850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69851       };
69852     } catch (Dali::DaliException e) {
69853       {
69854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69855       };
69856     } catch (...) {
69857       {
69858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69859       };
69860     }
69861   }
69862
69863 }
69864
69865
69866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69867   void * jresult ;
69868   Dali::Toolkit::Button *result = 0 ;
69869
69870   {
69871     try {
69872       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69873     } catch (std::out_of_range& e) {
69874       {
69875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69876       };
69877     } catch (std::exception& e) {
69878       {
69879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69880       };
69881     } catch (Dali::DaliException e) {
69882       {
69883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69884       };
69885     } catch (...) {
69886       {
69887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69888       };
69889     }
69890   }
69891
69892   jresult = (void *)result;
69893   return jresult;
69894 }
69895
69896
69897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69898   void * jresult ;
69899   Dali::Toolkit::Button *arg1 = 0 ;
69900   Dali::Toolkit::Button *result = 0 ;
69901
69902   arg1 = (Dali::Toolkit::Button *)jarg1;
69903   if (!arg1) {
69904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69905     return 0;
69906   }
69907   {
69908     try {
69909       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69910     } catch (std::out_of_range& e) {
69911       {
69912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69913       };
69914     } catch (std::exception& e) {
69915       {
69916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69917       };
69918     } catch (Dali::DaliException e) {
69919       {
69920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69921       };
69922     } catch (...) {
69923       {
69924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69925       };
69926     }
69927   }
69928
69929   jresult = (void *)result;
69930   return jresult;
69931 }
69932
69933
69934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69935   void * jresult ;
69936   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69937   Dali::Toolkit::Button *arg2 = 0 ;
69938   Dali::Toolkit::Button *result = 0 ;
69939
69940   arg1 = (Dali::Toolkit::Button *)jarg1;
69941   arg2 = (Dali::Toolkit::Button *)jarg2;
69942   if (!arg2) {
69943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69944     return 0;
69945   }
69946   {
69947     try {
69948       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69949     } catch (std::out_of_range& e) {
69950       {
69951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69952       };
69953     } catch (std::exception& e) {
69954       {
69955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69956       };
69957     } catch (Dali::DaliException e) {
69958       {
69959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69960       };
69961     } catch (...) {
69962       {
69963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69964       };
69965     }
69966   }
69967
69968   jresult = (void *)result;
69969   return jresult;
69970 }
69971
69972
69973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69974   void * jresult ;
69975   Dali::BaseHandle arg1 ;
69976   Dali::BaseHandle *argp1 ;
69977   Dali::Toolkit::Button result;
69978
69979   argp1 = (Dali::BaseHandle *)jarg1;
69980   if (!argp1) {
69981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69982     return 0;
69983   }
69984   arg1 = *argp1;
69985   {
69986     try {
69987       result = Dali::Toolkit::Button::DownCast(arg1);
69988     } catch (std::out_of_range& e) {
69989       {
69990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69991       };
69992     } catch (std::exception& e) {
69993       {
69994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69995       };
69996     } catch (Dali::DaliException e) {
69997       {
69998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69999       };
70000     } catch (...) {
70001       {
70002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70003       };
70004     }
70005   }
70006
70007   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
70008   return jresult;
70009 }
70010
70011
70012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
70013   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70014
70015   arg1 = (Dali::Toolkit::Button *)jarg1;
70016   {
70017     try {
70018       delete arg1;
70019     } catch (std::out_of_range& e) {
70020       {
70021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70022       };
70023     } catch (std::exception& e) {
70024       {
70025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70026       };
70027     } catch (Dali::DaliException e) {
70028       {
70029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70030       };
70031     } catch (...) {
70032       {
70033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70034       };
70035     }
70036   }
70037
70038 }
70039
70040
70041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
70042   unsigned int jresult ;
70043   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70044   bool result;
70045
70046   arg1 = (Dali::Toolkit::Button *)jarg1;
70047   {
70048     try {
70049       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
70050     } catch (std::out_of_range& e) {
70051       {
70052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70053       };
70054     } catch (std::exception& e) {
70055       {
70056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70057       };
70058     } catch (Dali::DaliException e) {
70059       {
70060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70061       };
70062     } catch (...) {
70063       {
70064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70065       };
70066     }
70067   }
70068
70069   jresult = result;
70070   return jresult;
70071 }
70072
70073
70074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
70075   unsigned int jresult ;
70076   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70077   bool result;
70078
70079   arg1 = (Dali::Toolkit::Button *)jarg1;
70080   {
70081     try {
70082       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
70083     } catch (std::out_of_range& e) {
70084       {
70085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70086       };
70087     } catch (std::exception& e) {
70088       {
70089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70090       };
70091     } catch (Dali::DaliException e) {
70092       {
70093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70094       };
70095     } catch (...) {
70096       {
70097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70098       };
70099     }
70100   }
70101
70102   jresult = result;
70103   return jresult;
70104 }
70105
70106
70107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
70108   float jresult ;
70109   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70110   float result;
70111
70112   arg1 = (Dali::Toolkit::Button *)jarg1;
70113   {
70114     try {
70115       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
70116     } catch (std::out_of_range& e) {
70117       {
70118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70119       };
70120     } catch (std::exception& e) {
70121       {
70122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70123       };
70124     } catch (Dali::DaliException e) {
70125       {
70126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70127       };
70128     } catch (...) {
70129       {
70130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70131       };
70132     }
70133   }
70134
70135   jresult = result;
70136   return jresult;
70137 }
70138
70139
70140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
70141   float jresult ;
70142   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70143   float result;
70144
70145   arg1 = (Dali::Toolkit::Button *)jarg1;
70146   {
70147     try {
70148       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70149     } catch (std::out_of_range& e) {
70150       {
70151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70152       };
70153     } catch (std::exception& e) {
70154       {
70155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70156       };
70157     } catch (Dali::DaliException e) {
70158       {
70159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70160       };
70161     } catch (...) {
70162       {
70163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70164       };
70165     }
70166   }
70167
70168   jresult = result;
70169   return jresult;
70170 }
70171
70172
70173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70174   unsigned int jresult ;
70175   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70176   bool result;
70177
70178   arg1 = (Dali::Toolkit::Button *)jarg1;
70179   {
70180     try {
70181       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70182     } catch (std::out_of_range& e) {
70183       {
70184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70185       };
70186     } catch (std::exception& e) {
70187       {
70188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70189       };
70190     } catch (Dali::DaliException e) {
70191       {
70192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70193       };
70194     } catch (...) {
70195       {
70196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70197       };
70198     }
70199   }
70200
70201   jresult = result;
70202   return jresult;
70203 }
70204
70205
70206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70207   unsigned int jresult ;
70208   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70209   bool result;
70210
70211   arg1 = (Dali::Toolkit::Button *)jarg1;
70212   {
70213     try {
70214       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70215     } catch (std::out_of_range& e) {
70216       {
70217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70218       };
70219     } catch (std::exception& e) {
70220       {
70221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70222       };
70223     } catch (Dali::DaliException e) {
70224       {
70225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70226       };
70227     } catch (...) {
70228       {
70229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70230       };
70231     }
70232   }
70233
70234   jresult = result;
70235   return jresult;
70236 }
70237
70238
70239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70240   float jresult ;
70241   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70242   float result;
70243
70244   arg1 = (Dali::Toolkit::Button *)jarg1;
70245   {
70246     try {
70247       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70248     } catch (std::out_of_range& e) {
70249       {
70250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70251       };
70252     } catch (std::exception& e) {
70253       {
70254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70255       };
70256     } catch (Dali::DaliException e) {
70257       {
70258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70259       };
70260     } catch (...) {
70261       {
70262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70263       };
70264     }
70265   }
70266
70267   jresult = result;
70268   return jresult;
70269 }
70270
70271
70272 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70273   char * jresult ;
70274   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70275   std::string result;
70276
70277   arg1 = (Dali::Toolkit::Button *)jarg1;
70278   {
70279     try {
70280       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70281     } catch (std::out_of_range& e) {
70282       {
70283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70284       };
70285     } catch (std::exception& e) {
70286       {
70287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70288       };
70289     } catch (Dali::DaliException e) {
70290       {
70291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70292       };
70293     } catch (...) {
70294       {
70295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70296       };
70297     }
70298   }
70299
70300   jresult = SWIG_csharp_string_callback((&result)->c_str());
70301   return jresult;
70302 }
70303
70304
70305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70306   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70307   Dali::Actor arg2 ;
70308   Dali::Actor *argp2 ;
70309
70310   arg1 = (Dali::Toolkit::Button *)jarg1;
70311   argp2 = (Dali::Actor *)jarg2;
70312   if (!argp2) {
70313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70314     return ;
70315   }
70316   arg2 = *argp2;
70317   {
70318     try {
70319       (arg1)->SetLabel(arg2);
70320     } catch (std::out_of_range& e) {
70321       {
70322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70323       };
70324     } catch (std::exception& e) {
70325       {
70326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70327       };
70328     } catch (Dali::DaliException e) {
70329       {
70330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70331       };
70332     } catch (...) {
70333       {
70334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70335       };
70336     }
70337   }
70338
70339 }
70340
70341
70342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70343   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70344   Dali::Image arg2 ;
70345   Dali::Image *argp2 ;
70346
70347   arg1 = (Dali::Toolkit::Button *)jarg1;
70348   argp2 = (Dali::Image *)jarg2;
70349   if (!argp2) {
70350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70351     return ;
70352   }
70353   arg2 = *argp2;
70354   {
70355     try {
70356       (arg1)->SetButtonImage(arg2);
70357     } catch (std::out_of_range& e) {
70358       {
70359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70360       };
70361     } catch (std::exception& e) {
70362       {
70363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70364       };
70365     } catch (Dali::DaliException e) {
70366       {
70367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70368       };
70369     } catch (...) {
70370       {
70371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70372       };
70373     }
70374   }
70375
70376 }
70377
70378
70379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70380   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70381   Dali::Image arg2 ;
70382   Dali::Image *argp2 ;
70383
70384   arg1 = (Dali::Toolkit::Button *)jarg1;
70385   argp2 = (Dali::Image *)jarg2;
70386   if (!argp2) {
70387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70388     return ;
70389   }
70390   arg2 = *argp2;
70391   {
70392     try {
70393       (arg1)->SetSelectedImage(arg2);
70394     } catch (std::out_of_range& e) {
70395       {
70396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70397       };
70398     } catch (std::exception& e) {
70399       {
70400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70401       };
70402     } catch (Dali::DaliException e) {
70403       {
70404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70405       };
70406     } catch (...) {
70407       {
70408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70409       };
70410     }
70411   }
70412
70413 }
70414
70415
70416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70417   void * jresult ;
70418   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70419   Dali::Actor result;
70420
70421   arg1 = (Dali::Toolkit::Button *)jarg1;
70422   {
70423     try {
70424       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70425     } catch (std::out_of_range& e) {
70426       {
70427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70428       };
70429     } catch (std::exception& e) {
70430       {
70431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70432       };
70433     } catch (Dali::DaliException e) {
70434       {
70435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70436       };
70437     } catch (...) {
70438       {
70439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70440       };
70441     }
70442   }
70443
70444   jresult = new Dali::Actor((const Dali::Actor &)result);
70445   return jresult;
70446 }
70447
70448
70449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70450   void * jresult ;
70451   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70452   Dali::Actor result;
70453
70454   arg1 = (Dali::Toolkit::Button *)jarg1;
70455   {
70456     try {
70457       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70458     } catch (std::out_of_range& e) {
70459       {
70460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70461       };
70462     } catch (std::exception& e) {
70463       {
70464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70465       };
70466     } catch (Dali::DaliException e) {
70467       {
70468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70469       };
70470     } catch (...) {
70471       {
70472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70473       };
70474     }
70475   }
70476
70477   jresult = new Dali::Actor((const Dali::Actor &)result);
70478   return jresult;
70479 }
70480
70481
70482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70483   void * jresult ;
70484   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70485   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70486
70487   arg1 = (Dali::Toolkit::Button *)jarg1;
70488   {
70489     try {
70490       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70491     } catch (std::out_of_range& e) {
70492       {
70493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70494       };
70495     } catch (std::exception& e) {
70496       {
70497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70498       };
70499     } catch (Dali::DaliException e) {
70500       {
70501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70502       };
70503     } catch (...) {
70504       {
70505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70506       };
70507     }
70508   }
70509
70510   jresult = (void *)result;
70511   return jresult;
70512 }
70513
70514
70515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70516   void * jresult ;
70517   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70518   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70519
70520   arg1 = (Dali::Toolkit::Button *)jarg1;
70521   {
70522     try {
70523       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70524     } catch (std::out_of_range& e) {
70525       {
70526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70527       };
70528     } catch (std::exception& e) {
70529       {
70530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70531       };
70532     } catch (Dali::DaliException e) {
70533       {
70534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70535       };
70536     } catch (...) {
70537       {
70538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70539       };
70540     }
70541   }
70542
70543   jresult = (void *)result;
70544   return jresult;
70545 }
70546
70547
70548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70549   void * jresult ;
70550   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70551   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70552
70553   arg1 = (Dali::Toolkit::Button *)jarg1;
70554   {
70555     try {
70556       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70557     } catch (std::out_of_range& e) {
70558       {
70559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70560       };
70561     } catch (std::exception& e) {
70562       {
70563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70564       };
70565     } catch (Dali::DaliException e) {
70566       {
70567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70568       };
70569     } catch (...) {
70570       {
70571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70572       };
70573     }
70574   }
70575
70576   jresult = (void *)result;
70577   return jresult;
70578 }
70579
70580
70581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70582   void * jresult ;
70583   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70584   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70585
70586   arg1 = (Dali::Toolkit::Button *)jarg1;
70587   {
70588     try {
70589       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70590     } catch (std::out_of_range& e) {
70591       {
70592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70593       };
70594     } catch (std::exception& e) {
70595       {
70596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70597       };
70598     } catch (Dali::DaliException e) {
70599       {
70600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70601       };
70602     } catch (...) {
70603       {
70604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70605       };
70606     }
70607   }
70608
70609   jresult = (void *)result;
70610   return jresult;
70611 }
70612
70613
70614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70615   void * jresult ;
70616   Dali::Toolkit::CheckBoxButton *result = 0 ;
70617
70618   {
70619     try {
70620       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70621     } catch (std::out_of_range& e) {
70622       {
70623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70624       };
70625     } catch (std::exception& e) {
70626       {
70627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70628       };
70629     } catch (Dali::DaliException e) {
70630       {
70631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70632       };
70633     } catch (...) {
70634       {
70635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70636       };
70637     }
70638   }
70639
70640   jresult = (void *)result;
70641   return jresult;
70642 }
70643
70644
70645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70646   void * jresult ;
70647   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70648   Dali::Toolkit::CheckBoxButton *result = 0 ;
70649
70650   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70651   if (!arg1) {
70652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70653     return 0;
70654   }
70655   {
70656     try {
70657       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70658     } catch (std::out_of_range& e) {
70659       {
70660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70661       };
70662     } catch (std::exception& e) {
70663       {
70664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70665       };
70666     } catch (Dali::DaliException e) {
70667       {
70668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70669       };
70670     } catch (...) {
70671       {
70672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70673       };
70674     }
70675   }
70676
70677   jresult = (void *)result;
70678   return jresult;
70679 }
70680
70681
70682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70683   void * jresult ;
70684   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70685   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70686   Dali::Toolkit::CheckBoxButton *result = 0 ;
70687
70688   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70689   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70690   if (!arg2) {
70691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70692     return 0;
70693   }
70694   {
70695     try {
70696       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70697     } catch (std::out_of_range& e) {
70698       {
70699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70700       };
70701     } catch (std::exception& e) {
70702       {
70703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70704       };
70705     } catch (Dali::DaliException e) {
70706       {
70707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70708       };
70709     } catch (...) {
70710       {
70711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70712       };
70713     }
70714   }
70715
70716   jresult = (void *)result;
70717   return jresult;
70718 }
70719
70720
70721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70722   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70723
70724   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70725   {
70726     try {
70727       delete arg1;
70728     } catch (std::out_of_range& e) {
70729       {
70730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70731       };
70732     } catch (std::exception& e) {
70733       {
70734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70735       };
70736     } catch (Dali::DaliException e) {
70737       {
70738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70739       };
70740     } catch (...) {
70741       {
70742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70743       };
70744     }
70745   }
70746
70747 }
70748
70749
70750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70751   void * jresult ;
70752   Dali::Toolkit::CheckBoxButton result;
70753
70754   {
70755     try {
70756       result = Dali::Toolkit::CheckBoxButton::New();
70757     } catch (std::out_of_range& e) {
70758       {
70759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70760       };
70761     } catch (std::exception& e) {
70762       {
70763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70764       };
70765     } catch (Dali::DaliException e) {
70766       {
70767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70768       };
70769     } catch (...) {
70770       {
70771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70772       };
70773     }
70774   }
70775
70776   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70777   return jresult;
70778 }
70779
70780
70781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70782   void * jresult ;
70783   Dali::BaseHandle arg1 ;
70784   Dali::BaseHandle *argp1 ;
70785   Dali::Toolkit::CheckBoxButton result;
70786
70787   argp1 = (Dali::BaseHandle *)jarg1;
70788   if (!argp1) {
70789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70790     return 0;
70791   }
70792   arg1 = *argp1;
70793   {
70794     try {
70795       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70796     } catch (std::out_of_range& e) {
70797       {
70798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70799       };
70800     } catch (std::exception& e) {
70801       {
70802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70803       };
70804     } catch (Dali::DaliException e) {
70805       {
70806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70807       };
70808     } catch (...) {
70809       {
70810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70811       };
70812     }
70813   }
70814
70815   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70816   return jresult;
70817 }
70818
70819
70820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70821   int jresult ;
70822   int result;
70823
70824   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70825   jresult = (int)result;
70826   return jresult;
70827 }
70828
70829
70830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70831   int jresult ;
70832   int result;
70833
70834   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70835   jresult = (int)result;
70836   return jresult;
70837 }
70838
70839
70840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70841   int jresult ;
70842   int result;
70843
70844   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70845   jresult = (int)result;
70846   return jresult;
70847 }
70848
70849
70850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70851   int jresult ;
70852   int result;
70853
70854   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70855   jresult = (int)result;
70856   return jresult;
70857 }
70858
70859
70860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70861   int jresult ;
70862   int result;
70863
70864   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70865   jresult = (int)result;
70866   return jresult;
70867 }
70868
70869
70870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70871   void * jresult ;
70872   Dali::Toolkit::PushButton::Property *result = 0 ;
70873
70874   {
70875     try {
70876       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70877     } catch (std::out_of_range& e) {
70878       {
70879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70880       };
70881     } catch (std::exception& e) {
70882       {
70883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70884       };
70885     } catch (Dali::DaliException e) {
70886       {
70887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70888       };
70889     } catch (...) {
70890       {
70891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70892       };
70893     }
70894   }
70895
70896   jresult = (void *)result;
70897   return jresult;
70898 }
70899
70900
70901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70902   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70903
70904   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70905   {
70906     try {
70907       delete arg1;
70908     } catch (std::out_of_range& e) {
70909       {
70910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70911       };
70912     } catch (std::exception& e) {
70913       {
70914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70915       };
70916     } catch (Dali::DaliException e) {
70917       {
70918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70919       };
70920     } catch (...) {
70921       {
70922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70923       };
70924     }
70925   }
70926
70927 }
70928
70929
70930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70931   void * jresult ;
70932   Dali::Toolkit::PushButton *result = 0 ;
70933
70934   {
70935     try {
70936       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70937     } catch (std::out_of_range& e) {
70938       {
70939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70940       };
70941     } catch (std::exception& e) {
70942       {
70943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70944       };
70945     } catch (Dali::DaliException e) {
70946       {
70947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70948       };
70949     } catch (...) {
70950       {
70951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70952       };
70953     }
70954   }
70955
70956   jresult = (void *)result;
70957   return jresult;
70958 }
70959
70960
70961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70962   void * jresult ;
70963   Dali::Toolkit::PushButton *arg1 = 0 ;
70964   Dali::Toolkit::PushButton *result = 0 ;
70965
70966   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70967   if (!arg1) {
70968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70969     return 0;
70970   }
70971   {
70972     try {
70973       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70974     } catch (std::out_of_range& e) {
70975       {
70976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70977       };
70978     } catch (std::exception& e) {
70979       {
70980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70981       };
70982     } catch (Dali::DaliException e) {
70983       {
70984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70985       };
70986     } catch (...) {
70987       {
70988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70989       };
70990     }
70991   }
70992
70993   jresult = (void *)result;
70994   return jresult;
70995 }
70996
70997
70998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70999   void * jresult ;
71000   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71001   Dali::Toolkit::PushButton *arg2 = 0 ;
71002   Dali::Toolkit::PushButton *result = 0 ;
71003
71004   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71005   arg2 = (Dali::Toolkit::PushButton *)jarg2;
71006   if (!arg2) {
71007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
71008     return 0;
71009   }
71010   {
71011     try {
71012       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
71013     } catch (std::out_of_range& e) {
71014       {
71015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71016       };
71017     } catch (std::exception& e) {
71018       {
71019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71020       };
71021     } catch (Dali::DaliException e) {
71022       {
71023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71024       };
71025     } catch (...) {
71026       {
71027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71028       };
71029     }
71030   }
71031
71032   jresult = (void *)result;
71033   return jresult;
71034 }
71035
71036
71037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
71038   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71039
71040   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71041   {
71042     try {
71043       delete arg1;
71044     } catch (std::out_of_range& e) {
71045       {
71046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71047       };
71048     } catch (std::exception& e) {
71049       {
71050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71051       };
71052     } catch (Dali::DaliException e) {
71053       {
71054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71055       };
71056     } catch (...) {
71057       {
71058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71059       };
71060     }
71061   }
71062
71063 }
71064
71065
71066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
71067   void * jresult ;
71068   Dali::Toolkit::PushButton result;
71069
71070   {
71071     try {
71072       result = Dali::Toolkit::PushButton::New();
71073     } catch (std::out_of_range& e) {
71074       {
71075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71076       };
71077     } catch (std::exception& e) {
71078       {
71079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71080       };
71081     } catch (Dali::DaliException e) {
71082       {
71083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71084       };
71085     } catch (...) {
71086       {
71087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71088       };
71089     }
71090   }
71091
71092   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71093   return jresult;
71094 }
71095
71096
71097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
71098   void * jresult ;
71099   Dali::BaseHandle arg1 ;
71100   Dali::BaseHandle *argp1 ;
71101   Dali::Toolkit::PushButton result;
71102
71103   argp1 = (Dali::BaseHandle *)jarg1;
71104   if (!argp1) {
71105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71106     return 0;
71107   }
71108   arg1 = *argp1;
71109   {
71110     try {
71111       result = Dali::Toolkit::PushButton::DownCast(arg1);
71112     } catch (std::out_of_range& e) {
71113       {
71114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71115       };
71116     } catch (std::exception& e) {
71117       {
71118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71119       };
71120     } catch (Dali::DaliException e) {
71121       {
71122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71123       };
71124     } catch (...) {
71125       {
71126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71127       };
71128     }
71129   }
71130
71131   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71132   return jresult;
71133 }
71134
71135
71136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
71137   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71138   Dali::Image arg2 ;
71139   Dali::Image *argp2 ;
71140
71141   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71142   argp2 = (Dali::Image *)jarg2;
71143   if (!argp2) {
71144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71145     return ;
71146   }
71147   arg2 = *argp2;
71148   {
71149     try {
71150       (arg1)->SetButtonImage(arg2);
71151     } catch (std::out_of_range& e) {
71152       {
71153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71154       };
71155     } catch (std::exception& e) {
71156       {
71157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71158       };
71159     } catch (Dali::DaliException e) {
71160       {
71161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71162       };
71163     } catch (...) {
71164       {
71165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71166       };
71167     }
71168   }
71169
71170 }
71171
71172
71173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71174   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71175   Dali::Actor arg2 ;
71176   Dali::Actor *argp2 ;
71177
71178   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71179   argp2 = (Dali::Actor *)jarg2;
71180   if (!argp2) {
71181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71182     return ;
71183   }
71184   arg2 = *argp2;
71185   {
71186     try {
71187       (arg1)->SetButtonImage(arg2);
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_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
71211   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71212   Dali::Actor arg2 ;
71213   Dali::Actor *argp2 ;
71214
71215   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71216   argp2 = (Dali::Actor *)jarg2;
71217   if (!argp2) {
71218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71219     return ;
71220   }
71221   arg2 = *argp2;
71222   {
71223     try {
71224       (arg1)->SetBackgroundImage(arg2);
71225     } catch (std::out_of_range& e) {
71226       {
71227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71228       };
71229     } catch (std::exception& e) {
71230       {
71231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71232       };
71233     } catch (Dali::DaliException e) {
71234       {
71235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71236       };
71237     } catch (...) {
71238       {
71239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71240       };
71241     }
71242   }
71243
71244 }
71245
71246
71247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71248   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71249   Dali::Image arg2 ;
71250   Dali::Image *argp2 ;
71251
71252   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71253   argp2 = (Dali::Image *)jarg2;
71254   if (!argp2) {
71255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71256     return ;
71257   }
71258   arg2 = *argp2;
71259   {
71260     try {
71261       (arg1)->SetSelectedImage(arg2);
71262     } catch (std::out_of_range& e) {
71263       {
71264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71265       };
71266     } catch (std::exception& e) {
71267       {
71268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71269       };
71270     } catch (Dali::DaliException e) {
71271       {
71272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71273       };
71274     } catch (...) {
71275       {
71276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71277       };
71278     }
71279   }
71280
71281 }
71282
71283
71284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
71285   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71286   Dali::Actor arg2 ;
71287   Dali::Actor *argp2 ;
71288
71289   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71290   argp2 = (Dali::Actor *)jarg2;
71291   if (!argp2) {
71292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71293     return ;
71294   }
71295   arg2 = *argp2;
71296   {
71297     try {
71298       (arg1)->SetSelectedImage(arg2);
71299     } catch (std::out_of_range& e) {
71300       {
71301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71302       };
71303     } catch (std::exception& e) {
71304       {
71305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71306       };
71307     } catch (Dali::DaliException e) {
71308       {
71309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71310       };
71311     } catch (...) {
71312       {
71313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71314       };
71315     }
71316   }
71317
71318 }
71319
71320
71321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71322   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71323   Dali::Actor arg2 ;
71324   Dali::Actor *argp2 ;
71325
71326   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71327   argp2 = (Dali::Actor *)jarg2;
71328   if (!argp2) {
71329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71330     return ;
71331   }
71332   arg2 = *argp2;
71333   {
71334     try {
71335       (arg1)->SetSelectedBackgroundImage(arg2);
71336     } catch (std::out_of_range& e) {
71337       {
71338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71339       };
71340     } catch (std::exception& e) {
71341       {
71342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71343       };
71344     } catch (Dali::DaliException e) {
71345       {
71346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71347       };
71348     } catch (...) {
71349       {
71350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71351       };
71352     }
71353   }
71354
71355 }
71356
71357
71358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71359   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71360   Dali::Actor arg2 ;
71361   Dali::Actor *argp2 ;
71362
71363   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71364   argp2 = (Dali::Actor *)jarg2;
71365   if (!argp2) {
71366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71367     return ;
71368   }
71369   arg2 = *argp2;
71370   {
71371     try {
71372       (arg1)->SetDisabledBackgroundImage(arg2);
71373     } catch (std::out_of_range& e) {
71374       {
71375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71376       };
71377     } catch (std::exception& e) {
71378       {
71379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71380       };
71381     } catch (Dali::DaliException e) {
71382       {
71383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71384       };
71385     } catch (...) {
71386       {
71387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71388       };
71389     }
71390   }
71391
71392 }
71393
71394
71395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71396   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71397   Dali::Actor arg2 ;
71398   Dali::Actor *argp2 ;
71399
71400   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71401   argp2 = (Dali::Actor *)jarg2;
71402   if (!argp2) {
71403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71404     return ;
71405   }
71406   arg2 = *argp2;
71407   {
71408     try {
71409       (arg1)->SetDisabledImage(arg2);
71410     } catch (std::out_of_range& e) {
71411       {
71412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71413       };
71414     } catch (std::exception& e) {
71415       {
71416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71417       };
71418     } catch (Dali::DaliException e) {
71419       {
71420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71421       };
71422     } catch (...) {
71423       {
71424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71425       };
71426     }
71427   }
71428
71429 }
71430
71431
71432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71433   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71434   Dali::Actor arg2 ;
71435   Dali::Actor *argp2 ;
71436
71437   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71438   argp2 = (Dali::Actor *)jarg2;
71439   if (!argp2) {
71440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71441     return ;
71442   }
71443   arg2 = *argp2;
71444   {
71445     try {
71446       (arg1)->SetDisabledSelectedImage(arg2);
71447     } catch (std::out_of_range& e) {
71448       {
71449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71450       };
71451     } catch (std::exception& e) {
71452       {
71453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71454       };
71455     } catch (Dali::DaliException e) {
71456       {
71457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71458       };
71459     } catch (...) {
71460       {
71461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71462       };
71463     }
71464   }
71465
71466 }
71467
71468
71469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71470   void * jresult ;
71471   Dali::Toolkit::RadioButton *result = 0 ;
71472
71473   {
71474     try {
71475       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71476     } catch (std::out_of_range& e) {
71477       {
71478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71479       };
71480     } catch (std::exception& e) {
71481       {
71482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71483       };
71484     } catch (Dali::DaliException e) {
71485       {
71486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71487       };
71488     } catch (...) {
71489       {
71490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71491       };
71492     }
71493   }
71494
71495   jresult = (void *)result;
71496   return jresult;
71497 }
71498
71499
71500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71501   void * jresult ;
71502   Dali::Toolkit::RadioButton *arg1 = 0 ;
71503   Dali::Toolkit::RadioButton *result = 0 ;
71504
71505   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71506   if (!arg1) {
71507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71508     return 0;
71509   }
71510   {
71511     try {
71512       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71513     } catch (std::out_of_range& e) {
71514       {
71515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71516       };
71517     } catch (std::exception& e) {
71518       {
71519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71520       };
71521     } catch (Dali::DaliException e) {
71522       {
71523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71524       };
71525     } catch (...) {
71526       {
71527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71528       };
71529     }
71530   }
71531
71532   jresult = (void *)result;
71533   return jresult;
71534 }
71535
71536
71537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71538   void * jresult ;
71539   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71540   Dali::Toolkit::RadioButton *arg2 = 0 ;
71541   Dali::Toolkit::RadioButton *result = 0 ;
71542
71543   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71544   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71545   if (!arg2) {
71546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71547     return 0;
71548   }
71549   {
71550     try {
71551       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71552     } catch (std::out_of_range& e) {
71553       {
71554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71555       };
71556     } catch (std::exception& e) {
71557       {
71558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71559       };
71560     } catch (Dali::DaliException e) {
71561       {
71562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71563       };
71564     } catch (...) {
71565       {
71566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71567       };
71568     }
71569   }
71570
71571   jresult = (void *)result;
71572   return jresult;
71573 }
71574
71575
71576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71577   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71578
71579   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71580   {
71581     try {
71582       delete arg1;
71583     } catch (std::out_of_range& e) {
71584       {
71585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71586       };
71587     } catch (std::exception& e) {
71588       {
71589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71590       };
71591     } catch (Dali::DaliException e) {
71592       {
71593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71594       };
71595     } catch (...) {
71596       {
71597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71598       };
71599     }
71600   }
71601
71602 }
71603
71604
71605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71606   void * jresult ;
71607   Dali::Toolkit::RadioButton result;
71608
71609   {
71610     try {
71611       result = Dali::Toolkit::RadioButton::New();
71612     } catch (std::out_of_range& e) {
71613       {
71614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71615       };
71616     } catch (std::exception& e) {
71617       {
71618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71619       };
71620     } catch (Dali::DaliException e) {
71621       {
71622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71623       };
71624     } catch (...) {
71625       {
71626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71627       };
71628     }
71629   }
71630
71631   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71632   return jresult;
71633 }
71634
71635
71636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71637   void * jresult ;
71638   std::string *arg1 = 0 ;
71639   Dali::Toolkit::RadioButton result;
71640
71641   if (!jarg1) {
71642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71643     return 0;
71644   }
71645   std::string arg1_str(jarg1);
71646   arg1 = &arg1_str;
71647   {
71648     try {
71649       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71650     } catch (std::out_of_range& e) {
71651       {
71652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71653       };
71654     } catch (std::exception& e) {
71655       {
71656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71657       };
71658     } catch (Dali::DaliException e) {
71659       {
71660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71661       };
71662     } catch (...) {
71663       {
71664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71665       };
71666     }
71667   }
71668
71669   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71670
71671   //argout typemap for const std::string&
71672
71673   return jresult;
71674 }
71675
71676
71677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71678   void * jresult ;
71679   Dali::BaseHandle arg1 ;
71680   Dali::BaseHandle *argp1 ;
71681   Dali::Toolkit::RadioButton result;
71682
71683   argp1 = (Dali::BaseHandle *)jarg1;
71684   if (!argp1) {
71685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71686     return 0;
71687   }
71688   arg1 = *argp1;
71689   {
71690     try {
71691       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71692     } catch (std::out_of_range& e) {
71693       {
71694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71695       };
71696     } catch (std::exception& e) {
71697       {
71698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71699       };
71700     } catch (Dali::DaliException e) {
71701       {
71702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71703       };
71704     } catch (...) {
71705       {
71706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71707       };
71708     }
71709   }
71710
71711   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71712   return jresult;
71713 }
71714
71715
71716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71717   int jresult ;
71718   int result;
71719
71720   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71721   jresult = (int)result;
71722   return jresult;
71723 }
71724
71725
71726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71727   int jresult ;
71728   int result;
71729
71730   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71731   jresult = (int)result;
71732   return jresult;
71733 }
71734
71735
71736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71737   int jresult ;
71738   int result;
71739
71740   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71741   jresult = (int)result;
71742   return jresult;
71743 }
71744
71745
71746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71747   int jresult ;
71748   int result;
71749
71750   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71751   jresult = (int)result;
71752   return jresult;
71753 }
71754
71755
71756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71757   int jresult ;
71758   int result;
71759
71760   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71761   jresult = (int)result;
71762   return jresult;
71763 }
71764
71765
71766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71767   int jresult ;
71768   int result;
71769
71770   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71771   jresult = (int)result;
71772   return jresult;
71773 }
71774
71775
71776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71777   void * jresult ;
71778   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71779
71780   {
71781     try {
71782       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71783     } catch (std::out_of_range& e) {
71784       {
71785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71786       };
71787     } catch (std::exception& e) {
71788       {
71789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71790       };
71791     } catch (Dali::DaliException e) {
71792       {
71793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71794       };
71795     } catch (...) {
71796       {
71797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71798       };
71799     }
71800   }
71801
71802   jresult = (void *)result;
71803   return jresult;
71804 }
71805
71806
71807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71808   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71809
71810   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71811   {
71812     try {
71813       delete arg1;
71814     } catch (std::out_of_range& e) {
71815       {
71816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71817       };
71818     } catch (std::exception& e) {
71819       {
71820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71821       };
71822     } catch (Dali::DaliException e) {
71823       {
71824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71825       };
71826     } catch (...) {
71827       {
71828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71829       };
71830     }
71831   }
71832
71833 }
71834
71835
71836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71837   int jresult ;
71838   int result;
71839
71840   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71841   jresult = (int)result;
71842   return jresult;
71843 }
71844
71845
71846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71847   int jresult ;
71848   int result;
71849
71850   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71851   jresult = (int)result;
71852   return jresult;
71853 }
71854
71855
71856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71857   int jresult ;
71858   int result;
71859
71860   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71861   jresult = (int)result;
71862   return jresult;
71863 }
71864
71865
71866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71867   void * jresult ;
71868   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71869
71870   {
71871     try {
71872       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71873     } catch (std::out_of_range& e) {
71874       {
71875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71876       };
71877     } catch (std::exception& e) {
71878       {
71879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71880       };
71881     } catch (Dali::DaliException e) {
71882       {
71883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71884       };
71885     } catch (...) {
71886       {
71887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71888       };
71889     }
71890   }
71891
71892   jresult = (void *)result;
71893   return jresult;
71894 }
71895
71896
71897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71898   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71899
71900   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71901   {
71902     try {
71903       delete arg1;
71904     } catch (std::out_of_range& e) {
71905       {
71906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71907       };
71908     } catch (std::exception& e) {
71909       {
71910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71911       };
71912     } catch (Dali::DaliException e) {
71913       {
71914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71915       };
71916     } catch (...) {
71917       {
71918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71919       };
71920     }
71921   }
71922
71923 }
71924
71925
71926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71927   void * jresult ;
71928   Dali::Toolkit::FlexContainer *result = 0 ;
71929
71930   {
71931     try {
71932       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71933     } catch (std::out_of_range& e) {
71934       {
71935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71936       };
71937     } catch (std::exception& e) {
71938       {
71939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71940       };
71941     } catch (Dali::DaliException e) {
71942       {
71943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71944       };
71945     } catch (...) {
71946       {
71947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71948       };
71949     }
71950   }
71951
71952   jresult = (void *)result;
71953   return jresult;
71954 }
71955
71956
71957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71958   void * jresult ;
71959   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71960   Dali::Toolkit::FlexContainer *result = 0 ;
71961
71962   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71963   if (!arg1) {
71964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71965     return 0;
71966   }
71967   {
71968     try {
71969       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71970     } catch (std::out_of_range& e) {
71971       {
71972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71973       };
71974     } catch (std::exception& e) {
71975       {
71976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71977       };
71978     } catch (Dali::DaliException e) {
71979       {
71980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71981       };
71982     } catch (...) {
71983       {
71984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71985       };
71986     }
71987   }
71988
71989   jresult = (void *)result;
71990   return jresult;
71991 }
71992
71993
71994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71995   void * jresult ;
71996   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71997   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71998   Dali::Toolkit::FlexContainer *result = 0 ;
71999
72000   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72001   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
72002   if (!arg2) {
72003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
72004     return 0;
72005   }
72006   {
72007     try {
72008       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
72009     } catch (std::out_of_range& e) {
72010       {
72011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72012       };
72013     } catch (std::exception& e) {
72014       {
72015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72016       };
72017     } catch (Dali::DaliException e) {
72018       {
72019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72020       };
72021     } catch (...) {
72022       {
72023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72024       };
72025     }
72026   }
72027
72028   jresult = (void *)result;
72029   return jresult;
72030 }
72031
72032
72033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
72034   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
72035
72036   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72037   {
72038     try {
72039       delete arg1;
72040     } catch (std::out_of_range& e) {
72041       {
72042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72043       };
72044     } catch (std::exception& e) {
72045       {
72046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72047       };
72048     } catch (Dali::DaliException e) {
72049       {
72050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72051       };
72052     } catch (...) {
72053       {
72054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72055       };
72056     }
72057   }
72058
72059 }
72060
72061
72062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
72063   void * jresult ;
72064   Dali::Toolkit::FlexContainer result;
72065
72066   {
72067     try {
72068       result = Dali::Toolkit::FlexContainer::New();
72069     } catch (std::out_of_range& e) {
72070       {
72071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72072       };
72073     } catch (std::exception& e) {
72074       {
72075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72076       };
72077     } catch (Dali::DaliException e) {
72078       {
72079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72080       };
72081     } catch (...) {
72082       {
72083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72084       };
72085     }
72086   }
72087
72088   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72089   return jresult;
72090 }
72091
72092
72093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
72094   void * jresult ;
72095   Dali::BaseHandle arg1 ;
72096   Dali::BaseHandle *argp1 ;
72097   Dali::Toolkit::FlexContainer result;
72098
72099   argp1 = (Dali::BaseHandle *)jarg1;
72100   if (!argp1) {
72101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72102     return 0;
72103   }
72104   arg1 = *argp1;
72105   {
72106     try {
72107       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
72108     } catch (std::out_of_range& e) {
72109       {
72110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72111       };
72112     } catch (std::exception& e) {
72113       {
72114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72115       };
72116     } catch (Dali::DaliException e) {
72117       {
72118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72119       };
72120     } catch (...) {
72121       {
72122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72123       };
72124     }
72125   }
72126
72127   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72128   return jresult;
72129 }
72130
72131
72132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
72133   int jresult ;
72134   int result;
72135
72136   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
72137   jresult = (int)result;
72138   return jresult;
72139 }
72140
72141
72142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
72143   int jresult ;
72144   int result;
72145
72146   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72147   jresult = (int)result;
72148   return jresult;
72149 }
72150
72151
72152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72153   int jresult ;
72154   int result;
72155
72156   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72157   jresult = (int)result;
72158   return jresult;
72159 }
72160
72161
72162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72163   int jresult ;
72164   int result;
72165
72166   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72167   jresult = (int)result;
72168   return jresult;
72169 }
72170
72171
72172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72173   void * jresult ;
72174   Dali::Toolkit::ImageView::Property *result = 0 ;
72175
72176   {
72177     try {
72178       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72179     } catch (std::out_of_range& e) {
72180       {
72181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72182       };
72183     } catch (std::exception& e) {
72184       {
72185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72186       };
72187     } catch (Dali::DaliException e) {
72188       {
72189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72190       };
72191     } catch (...) {
72192       {
72193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72194       };
72195     }
72196   }
72197
72198   jresult = (void *)result;
72199   return jresult;
72200 }
72201
72202
72203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72204   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72205
72206   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72207   {
72208     try {
72209       delete arg1;
72210     } catch (std::out_of_range& e) {
72211       {
72212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72213       };
72214     } catch (std::exception& e) {
72215       {
72216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72217       };
72218     } catch (Dali::DaliException e) {
72219       {
72220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72221       };
72222     } catch (...) {
72223       {
72224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72225       };
72226     }
72227   }
72228
72229 }
72230
72231
72232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72233   void * jresult ;
72234   Dali::Toolkit::ImageView *result = 0 ;
72235
72236   {
72237     try {
72238       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72239     } catch (std::out_of_range& e) {
72240       {
72241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72242       };
72243     } catch (std::exception& e) {
72244       {
72245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72246       };
72247     } catch (Dali::DaliException e) {
72248       {
72249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72250       };
72251     } catch (...) {
72252       {
72253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72254       };
72255     }
72256   }
72257
72258   jresult = (void *)result;
72259   return jresult;
72260 }
72261
72262
72263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72264   void * jresult ;
72265   Dali::Toolkit::ImageView result;
72266
72267   {
72268     try {
72269       result = Dali::Toolkit::ImageView::New();
72270     } catch (std::out_of_range& e) {
72271       {
72272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72273       };
72274     } catch (std::exception& e) {
72275       {
72276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72277       };
72278     } catch (Dali::DaliException e) {
72279       {
72280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72281       };
72282     } catch (...) {
72283       {
72284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72285       };
72286     }
72287   }
72288
72289   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72290   return jresult;
72291 }
72292
72293
72294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72295   void * jresult ;
72296   Dali::Image arg1 ;
72297   Dali::Image *argp1 ;
72298   Dali::Toolkit::ImageView result;
72299
72300   argp1 = (Dali::Image *)jarg1;
72301   if (!argp1) {
72302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72303     return 0;
72304   }
72305   arg1 = *argp1;
72306   {
72307     try {
72308       result = Dali::Toolkit::ImageView::New(arg1);
72309     } catch (std::out_of_range& e) {
72310       {
72311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72312       };
72313     } catch (std::exception& e) {
72314       {
72315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72316       };
72317     } catch (Dali::DaliException e) {
72318       {
72319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72320       };
72321     } catch (...) {
72322       {
72323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72324       };
72325     }
72326   }
72327
72328   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72329   return jresult;
72330 }
72331
72332
72333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72334   void * jresult ;
72335   std::string *arg1 = 0 ;
72336   Dali::Toolkit::ImageView result;
72337
72338   if (!jarg1) {
72339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72340     return 0;
72341   }
72342   std::string arg1_str(jarg1);
72343   arg1 = &arg1_str;
72344   {
72345     try {
72346       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72347     } catch (std::out_of_range& e) {
72348       {
72349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72350       };
72351     } catch (std::exception& e) {
72352       {
72353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72354       };
72355     } catch (Dali::DaliException e) {
72356       {
72357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72358       };
72359     } catch (...) {
72360       {
72361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72362       };
72363     }
72364   }
72365
72366   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72367
72368   //argout typemap for const std::string&
72369
72370   return jresult;
72371 }
72372
72373
72374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72375   void * jresult ;
72376   std::string *arg1 = 0 ;
72377   Dali::ImageDimensions arg2 ;
72378   Dali::ImageDimensions *argp2 ;
72379   Dali::Toolkit::ImageView result;
72380
72381   if (!jarg1) {
72382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72383     return 0;
72384   }
72385   std::string arg1_str(jarg1);
72386   arg1 = &arg1_str;
72387   argp2 = (Dali::ImageDimensions *)jarg2;
72388   if (!argp2) {
72389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72390     return 0;
72391   }
72392   arg2 = *argp2;
72393   {
72394     try {
72395       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72396     } catch (std::out_of_range& e) {
72397       {
72398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72399       };
72400     } catch (std::exception& e) {
72401       {
72402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72403       };
72404     } catch (Dali::DaliException e) {
72405       {
72406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72407       };
72408     } catch (...) {
72409       {
72410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72411       };
72412     }
72413   }
72414
72415   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72416
72417   //argout typemap for const std::string&
72418
72419   return jresult;
72420 }
72421
72422
72423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72424   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72425
72426   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72427   {
72428     try {
72429       delete arg1;
72430     } catch (std::out_of_range& e) {
72431       {
72432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72433       };
72434     } catch (std::exception& e) {
72435       {
72436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72437       };
72438     } catch (Dali::DaliException e) {
72439       {
72440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72441       };
72442     } catch (...) {
72443       {
72444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72445       };
72446     }
72447   }
72448
72449 }
72450
72451
72452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72453   void * jresult ;
72454   Dali::Toolkit::ImageView *arg1 = 0 ;
72455   Dali::Toolkit::ImageView *result = 0 ;
72456
72457   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72458   if (!arg1) {
72459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72460     return 0;
72461   }
72462   {
72463     try {
72464       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72465     } catch (std::out_of_range& e) {
72466       {
72467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72468       };
72469     } catch (std::exception& e) {
72470       {
72471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72472       };
72473     } catch (Dali::DaliException e) {
72474       {
72475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72476       };
72477     } catch (...) {
72478       {
72479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72480       };
72481     }
72482   }
72483
72484   jresult = (void *)result;
72485   return jresult;
72486 }
72487
72488
72489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72490   void * jresult ;
72491   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72492   Dali::Toolkit::ImageView *arg2 = 0 ;
72493   Dali::Toolkit::ImageView *result = 0 ;
72494
72495   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72496   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72497   if (!arg2) {
72498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72499     return 0;
72500   }
72501   {
72502     try {
72503       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72504     } catch (std::out_of_range& e) {
72505       {
72506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72507       };
72508     } catch (std::exception& e) {
72509       {
72510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72511       };
72512     } catch (Dali::DaliException e) {
72513       {
72514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72515       };
72516     } catch (...) {
72517       {
72518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72519       };
72520     }
72521   }
72522
72523   jresult = (void *)result;
72524   return jresult;
72525 }
72526
72527
72528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72529   void * jresult ;
72530   Dali::BaseHandle arg1 ;
72531   Dali::BaseHandle *argp1 ;
72532   Dali::Toolkit::ImageView result;
72533
72534   argp1 = (Dali::BaseHandle *)jarg1;
72535   if (!argp1) {
72536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72537     return 0;
72538   }
72539   arg1 = *argp1;
72540   {
72541     try {
72542       result = Dali::Toolkit::ImageView::DownCast(arg1);
72543     } catch (std::out_of_range& e) {
72544       {
72545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72546       };
72547     } catch (std::exception& e) {
72548       {
72549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72550       };
72551     } catch (Dali::DaliException e) {
72552       {
72553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72554       };
72555     } catch (...) {
72556       {
72557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72558       };
72559     }
72560   }
72561
72562   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72563   return jresult;
72564 }
72565
72566
72567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72568   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72569   Dali::Image arg2 ;
72570   Dali::Image *argp2 ;
72571
72572   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72573   argp2 = (Dali::Image *)jarg2;
72574   if (!argp2) {
72575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72576     return ;
72577   }
72578   arg2 = *argp2;
72579   {
72580     try {
72581       (arg1)->SetImage(arg2);
72582     } catch (std::out_of_range& e) {
72583       {
72584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72585       };
72586     } catch (std::exception& e) {
72587       {
72588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72589       };
72590     } catch (Dali::DaliException e) {
72591       {
72592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72593       };
72594     } catch (...) {
72595       {
72596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72597       };
72598     }
72599   }
72600
72601 }
72602
72603
72604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72605   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72606   std::string *arg2 = 0 ;
72607
72608   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72609   if (!jarg2) {
72610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72611     return ;
72612   }
72613   std::string arg2_str(jarg2);
72614   arg2 = &arg2_str;
72615   {
72616     try {
72617       (arg1)->SetImage((std::string const &)*arg2);
72618     } catch (std::out_of_range& e) {
72619       {
72620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72621       };
72622     } catch (std::exception& e) {
72623       {
72624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72625       };
72626     } catch (Dali::DaliException e) {
72627       {
72628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72629       };
72630     } catch (...) {
72631       {
72632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72633       };
72634     }
72635   }
72636
72637
72638   //argout typemap for const std::string&
72639
72640 }
72641
72642
72643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72644   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72645   std::string *arg2 = 0 ;
72646   Dali::ImageDimensions arg3 ;
72647   Dali::ImageDimensions *argp3 ;
72648
72649   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72650   if (!jarg2) {
72651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72652     return ;
72653   }
72654   std::string arg2_str(jarg2);
72655   arg2 = &arg2_str;
72656   argp3 = (Dali::ImageDimensions *)jarg3;
72657   if (!argp3) {
72658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72659     return ;
72660   }
72661   arg3 = *argp3;
72662   {
72663     try {
72664       (arg1)->SetImage((std::string const &)*arg2,arg3);
72665     } catch (std::out_of_range& e) {
72666       {
72667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72668       };
72669     } catch (std::exception& e) {
72670       {
72671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72672       };
72673     } catch (Dali::DaliException e) {
72674       {
72675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72676       };
72677     } catch (...) {
72678       {
72679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72680       };
72681     }
72682   }
72683
72684
72685   //argout typemap for const std::string&
72686
72687 }
72688
72689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72690   void * jresult ;
72691   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72692   Dali::Image result;
72693
72694   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72695   {
72696     try {
72697       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72698     } catch (std::out_of_range& e) {
72699       {
72700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72701       };
72702     } catch (std::exception& e) {
72703       {
72704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72705       };
72706     } catch (Dali::DaliException e) {
72707       {
72708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72709       };
72710     } catch (...) {
72711       {
72712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72713       };
72714     }
72715   }
72716
72717   jresult = new Dali::Image((const Dali::Image &)result);
72718   return jresult;
72719 }
72720
72721
72722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72723   int jresult ;
72724   int result;
72725
72726   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72727   jresult = (int)result;
72728   return jresult;
72729 }
72730
72731
72732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72733   int jresult ;
72734   int result;
72735
72736   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72737   jresult = (int)result;
72738   return jresult;
72739 }
72740
72741
72742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72743   int jresult ;
72744   int result;
72745
72746   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72747   jresult = (int)result;
72748   return jresult;
72749 }
72750
72751
72752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72753   int jresult ;
72754   int result;
72755
72756   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72757   jresult = (int)result;
72758   return jresult;
72759 }
72760
72761
72762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72763   int jresult ;
72764   int result;
72765
72766   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72767   jresult = (int)result;
72768   return jresult;
72769 }
72770
72771
72772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72773   int jresult ;
72774   int result;
72775
72776   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72777   jresult = (int)result;
72778   return jresult;
72779 }
72780
72781
72782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72783   int jresult ;
72784   int result;
72785
72786   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72787   jresult = (int)result;
72788   return jresult;
72789 }
72790
72791
72792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72793   int jresult ;
72794   int result;
72795
72796   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72797   jresult = (int)result;
72798   return jresult;
72799 }
72800
72801
72802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72803   void * jresult ;
72804   Dali::Toolkit::Model3dView::Property *result = 0 ;
72805
72806   {
72807     try {
72808       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72809     } catch (std::out_of_range& e) {
72810       {
72811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72812       };
72813     } catch (std::exception& e) {
72814       {
72815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72816       };
72817     } catch (Dali::DaliException e) {
72818       {
72819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72820       };
72821     } catch (...) {
72822       {
72823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72824       };
72825     }
72826   }
72827
72828   jresult = (void *)result;
72829   return jresult;
72830 }
72831
72832
72833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72834   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72835
72836   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72837   {
72838     try {
72839       delete arg1;
72840     } catch (std::out_of_range& e) {
72841       {
72842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72843       };
72844     } catch (std::exception& e) {
72845       {
72846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72847       };
72848     } catch (Dali::DaliException e) {
72849       {
72850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72851       };
72852     } catch (...) {
72853       {
72854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72855       };
72856     }
72857   }
72858
72859 }
72860
72861
72862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72863   void * jresult ;
72864   Dali::Toolkit::Model3dView result;
72865
72866   {
72867     try {
72868       result = Dali::Toolkit::Model3dView::New();
72869     } catch (std::out_of_range& e) {
72870       {
72871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72872       };
72873     } catch (std::exception& e) {
72874       {
72875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72876       };
72877     } catch (Dali::DaliException e) {
72878       {
72879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72880       };
72881     } catch (...) {
72882       {
72883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72884       };
72885     }
72886   }
72887
72888   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72889   return jresult;
72890 }
72891
72892
72893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72894   void * jresult ;
72895   std::string *arg1 = 0 ;
72896   std::string *arg2 = 0 ;
72897   std::string *arg3 = 0 ;
72898   Dali::Toolkit::Model3dView result;
72899
72900   if (!jarg1) {
72901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72902     return 0;
72903   }
72904   std::string arg1_str(jarg1);
72905   arg1 = &arg1_str;
72906   if (!jarg2) {
72907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72908     return 0;
72909   }
72910   std::string arg2_str(jarg2);
72911   arg2 = &arg2_str;
72912   if (!jarg3) {
72913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72914     return 0;
72915   }
72916   std::string arg3_str(jarg3);
72917   arg3 = &arg3_str;
72918   {
72919     try {
72920       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72921     } catch (std::out_of_range& e) {
72922       {
72923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72924       };
72925     } catch (std::exception& e) {
72926       {
72927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72928       };
72929     } catch (Dali::DaliException e) {
72930       {
72931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72932       };
72933     } catch (...) {
72934       {
72935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72936       };
72937     }
72938   }
72939
72940   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72941
72942   //argout typemap for const std::string&
72943
72944
72945   //argout typemap for const std::string&
72946
72947
72948   //argout typemap for const std::string&
72949
72950   return jresult;
72951 }
72952
72953
72954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72955   void * jresult ;
72956   Dali::Toolkit::Model3dView *result = 0 ;
72957
72958   {
72959     try {
72960       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72961     } catch (std::out_of_range& e) {
72962       {
72963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72964       };
72965     } catch (std::exception& e) {
72966       {
72967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72968       };
72969     } catch (Dali::DaliException e) {
72970       {
72971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72972       };
72973     } catch (...) {
72974       {
72975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72976       };
72977     }
72978   }
72979
72980   jresult = (void *)result;
72981   return jresult;
72982 }
72983
72984
72985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72986   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72987
72988   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72989   {
72990     try {
72991       delete arg1;
72992     } catch (std::out_of_range& e) {
72993       {
72994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72995       };
72996     } catch (std::exception& e) {
72997       {
72998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72999       };
73000     } catch (Dali::DaliException e) {
73001       {
73002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73003       };
73004     } catch (...) {
73005       {
73006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73007       };
73008     }
73009   }
73010
73011 }
73012
73013
73014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
73015   void * jresult ;
73016   Dali::Toolkit::Model3dView *arg1 = 0 ;
73017   Dali::Toolkit::Model3dView *result = 0 ;
73018
73019   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73020   if (!arg1) {
73021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73022     return 0;
73023   }
73024   {
73025     try {
73026       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
73027     } catch (std::out_of_range& e) {
73028       {
73029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73030       };
73031     } catch (std::exception& e) {
73032       {
73033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73034       };
73035     } catch (Dali::DaliException e) {
73036       {
73037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73038       };
73039     } catch (...) {
73040       {
73041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73042       };
73043     }
73044   }
73045
73046   jresult = (void *)result;
73047   return jresult;
73048 }
73049
73050
73051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
73052   void * jresult ;
73053   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
73054   Dali::Toolkit::Model3dView *arg2 = 0 ;
73055   Dali::Toolkit::Model3dView *result = 0 ;
73056
73057   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73058   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
73059   if (!arg2) {
73060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73061     return 0;
73062   }
73063   {
73064     try {
73065       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
73066     } catch (std::out_of_range& e) {
73067       {
73068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73069       };
73070     } catch (std::exception& e) {
73071       {
73072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73073       };
73074     } catch (Dali::DaliException e) {
73075       {
73076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73077       };
73078     } catch (...) {
73079       {
73080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73081       };
73082     }
73083   }
73084
73085   jresult = (void *)result;
73086   return jresult;
73087 }
73088
73089
73090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
73091   void * jresult ;
73092   Dali::BaseHandle arg1 ;
73093   Dali::BaseHandle *argp1 ;
73094   Dali::Toolkit::Model3dView result;
73095
73096   argp1 = (Dali::BaseHandle *)jarg1;
73097   if (!argp1) {
73098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73099     return 0;
73100   }
73101   arg1 = *argp1;
73102   {
73103     try {
73104       result = Dali::Toolkit::Model3dView::DownCast(arg1);
73105     } catch (std::out_of_range& e) {
73106       {
73107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73108       };
73109     } catch (std::exception& e) {
73110       {
73111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73112       };
73113     } catch (Dali::DaliException e) {
73114       {
73115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73116       };
73117     } catch (...) {
73118       {
73119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73120       };
73121     }
73122   }
73123
73124   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
73125   return jresult;
73126 }
73127
73128
73129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
73130   int jresult ;
73131   int result;
73132
73133   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
73134   jresult = (int)result;
73135   return jresult;
73136 }
73137
73138
73139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
73140   int jresult ;
73141   int result;
73142
73143   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
73144   jresult = (int)result;
73145   return jresult;
73146 }
73147
73148
73149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73150   int jresult ;
73151   int result;
73152
73153   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73154   jresult = (int)result;
73155   return jresult;
73156 }
73157
73158
73159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73160   int jresult ;
73161   int result;
73162
73163   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73164   jresult = (int)result;
73165   return jresult;
73166 }
73167
73168
73169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73170   int jresult ;
73171   int result;
73172
73173   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73174   jresult = (int)result;
73175   return jresult;
73176 }
73177
73178
73179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73180   int jresult ;
73181   int result;
73182
73183   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73184   jresult = (int)result;
73185   return jresult;
73186 }
73187
73188
73189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73190   int jresult ;
73191   int result;
73192
73193   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73194   jresult = (int)result;
73195   return jresult;
73196 }
73197
73198
73199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73200   int jresult ;
73201   int result;
73202
73203   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73204   jresult = (int)result;
73205   return jresult;
73206 }
73207
73208
73209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73210   int jresult ;
73211   int result;
73212
73213   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73214   jresult = (int)result;
73215   return jresult;
73216 }
73217
73218
73219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73220   void * jresult ;
73221   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73222
73223   {
73224     try {
73225       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73226     } catch (std::out_of_range& e) {
73227       {
73228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73229       };
73230     } catch (std::exception& e) {
73231       {
73232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73233       };
73234     } catch (Dali::DaliException e) {
73235       {
73236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73237       };
73238     } catch (...) {
73239       {
73240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73241       };
73242     }
73243   }
73244
73245   jresult = (void *)result;
73246   return jresult;
73247 }
73248
73249
73250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73251   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73252
73253   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73254   {
73255     try {
73256       delete arg1;
73257     } catch (std::out_of_range& e) {
73258       {
73259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73260       };
73261     } catch (std::exception& e) {
73262       {
73263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73264       };
73265     } catch (Dali::DaliException e) {
73266       {
73267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73268       };
73269     } catch (...) {
73270       {
73271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73272       };
73273     }
73274   }
73275
73276 }
73277
73278
73279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73280   void * jresult ;
73281   Dali::Toolkit::ScrollBar *result = 0 ;
73282
73283   {
73284     try {
73285       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73286     } catch (std::out_of_range& e) {
73287       {
73288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73289       };
73290     } catch (std::exception& e) {
73291       {
73292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73293       };
73294     } catch (Dali::DaliException e) {
73295       {
73296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73297       };
73298     } catch (...) {
73299       {
73300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73301       };
73302     }
73303   }
73304
73305   jresult = (void *)result;
73306   return jresult;
73307 }
73308
73309
73310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73311   void * jresult ;
73312   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73313   Dali::Toolkit::ScrollBar *result = 0 ;
73314
73315   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73316   if (!arg1) {
73317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73318     return 0;
73319   }
73320   {
73321     try {
73322       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73323     } catch (std::out_of_range& e) {
73324       {
73325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73326       };
73327     } catch (std::exception& e) {
73328       {
73329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73330       };
73331     } catch (Dali::DaliException e) {
73332       {
73333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73334       };
73335     } catch (...) {
73336       {
73337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73338       };
73339     }
73340   }
73341
73342   jresult = (void *)result;
73343   return jresult;
73344 }
73345
73346
73347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73348   void * jresult ;
73349   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73350   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73351   Dali::Toolkit::ScrollBar *result = 0 ;
73352
73353   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73354   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73355   if (!arg2) {
73356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73357     return 0;
73358   }
73359   {
73360     try {
73361       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73362     } catch (std::out_of_range& e) {
73363       {
73364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73365       };
73366     } catch (std::exception& e) {
73367       {
73368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73369       };
73370     } catch (Dali::DaliException e) {
73371       {
73372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73373       };
73374     } catch (...) {
73375       {
73376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73377       };
73378     }
73379   }
73380
73381   jresult = (void *)result;
73382   return jresult;
73383 }
73384
73385
73386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73387   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73388
73389   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73390   {
73391     try {
73392       delete arg1;
73393     } catch (std::out_of_range& e) {
73394       {
73395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73396       };
73397     } catch (std::exception& e) {
73398       {
73399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73400       };
73401     } catch (Dali::DaliException e) {
73402       {
73403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73404       };
73405     } catch (...) {
73406       {
73407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73408       };
73409     }
73410   }
73411
73412 }
73413
73414
73415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73416   void * jresult ;
73417   Dali::Toolkit::ScrollBar::Direction arg1 ;
73418   Dali::Toolkit::ScrollBar result;
73419
73420   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73421   {
73422     try {
73423       result = Dali::Toolkit::ScrollBar::New(arg1);
73424     } catch (std::out_of_range& e) {
73425       {
73426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73427       };
73428     } catch (std::exception& e) {
73429       {
73430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73431       };
73432     } catch (Dali::DaliException e) {
73433       {
73434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73435       };
73436     } catch (...) {
73437       {
73438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73439       };
73440     }
73441   }
73442
73443   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73444   return jresult;
73445 }
73446
73447
73448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73449   void * jresult ;
73450   Dali::Toolkit::ScrollBar result;
73451
73452   {
73453     try {
73454       result = Dali::Toolkit::ScrollBar::New();
73455     } catch (std::out_of_range& e) {
73456       {
73457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73458       };
73459     } catch (std::exception& e) {
73460       {
73461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73462       };
73463     } catch (Dali::DaliException e) {
73464       {
73465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73466       };
73467     } catch (...) {
73468       {
73469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73470       };
73471     }
73472   }
73473
73474   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73475   return jresult;
73476 }
73477
73478
73479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73480   void * jresult ;
73481   Dali::BaseHandle arg1 ;
73482   Dali::BaseHandle *argp1 ;
73483   Dali::Toolkit::ScrollBar result;
73484
73485   argp1 = (Dali::BaseHandle *)jarg1;
73486   if (!argp1) {
73487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73488     return 0;
73489   }
73490   arg1 = *argp1;
73491   {
73492     try {
73493       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73494     } catch (std::out_of_range& e) {
73495       {
73496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73497       };
73498     } catch (std::exception& e) {
73499       {
73500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73501       };
73502     } catch (Dali::DaliException e) {
73503       {
73504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73505       };
73506     } catch (...) {
73507       {
73508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73509       };
73510     }
73511   }
73512
73513   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73514   return jresult;
73515 }
73516
73517
73518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73519   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73520   Dali::Handle arg2 ;
73521   Dali::Property::Index arg3 ;
73522   Dali::Property::Index arg4 ;
73523   Dali::Property::Index arg5 ;
73524   Dali::Property::Index arg6 ;
73525   Dali::Handle *argp2 ;
73526
73527   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73528   argp2 = (Dali::Handle *)jarg2;
73529   if (!argp2) {
73530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73531     return ;
73532   }
73533   arg2 = *argp2;
73534   arg3 = (Dali::Property::Index)jarg3;
73535   arg4 = (Dali::Property::Index)jarg4;
73536   arg5 = (Dali::Property::Index)jarg5;
73537   arg6 = (Dali::Property::Index)jarg6;
73538   {
73539     try {
73540       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73541     } catch (std::out_of_range& e) {
73542       {
73543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73544       };
73545     } catch (std::exception& e) {
73546       {
73547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73548       };
73549     } catch (Dali::DaliException e) {
73550       {
73551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73552       };
73553     } catch (...) {
73554       {
73555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73556       };
73557     }
73558   }
73559
73560 }
73561
73562
73563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73564   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73565   Dali::Actor arg2 ;
73566   Dali::Actor *argp2 ;
73567
73568   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73569   argp2 = (Dali::Actor *)jarg2;
73570   if (!argp2) {
73571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73572     return ;
73573   }
73574   arg2 = *argp2;
73575   {
73576     try {
73577       (arg1)->SetScrollIndicator(arg2);
73578     } catch (std::out_of_range& e) {
73579       {
73580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73581       };
73582     } catch (std::exception& e) {
73583       {
73584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73585       };
73586     } catch (Dali::DaliException e) {
73587       {
73588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73589       };
73590     } catch (...) {
73591       {
73592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73593       };
73594     }
73595   }
73596
73597 }
73598
73599
73600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73601   void * jresult ;
73602   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73603   Dali::Actor result;
73604
73605   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73606   {
73607     try {
73608       result = (arg1)->GetScrollIndicator();
73609     } catch (std::out_of_range& e) {
73610       {
73611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73612       };
73613     } catch (std::exception& e) {
73614       {
73615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73616       };
73617     } catch (Dali::DaliException e) {
73618       {
73619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73620       };
73621     } catch (...) {
73622       {
73623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73624       };
73625     }
73626   }
73627
73628   jresult = new Dali::Actor((const Dali::Actor &)result);
73629   return jresult;
73630 }
73631
73632
73633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73634   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73635   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73636
73637   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73638   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73639   if (!arg2) {
73640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73641     return ;
73642   }
73643   {
73644     try {
73645       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73646     } catch (std::out_of_range& e) {
73647       {
73648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73649       };
73650     } catch (std::exception& e) {
73651       {
73652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73653       };
73654     } catch (Dali::DaliException e) {
73655       {
73656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73657       };
73658     } catch (...) {
73659       {
73660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73661       };
73662     }
73663   }
73664
73665 }
73666
73667
73668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73669   void * jresult ;
73670   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73671
73672   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73673   {
73674     try {
73675       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()));
73676     } catch (std::out_of_range& e) {
73677       {
73678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73679       };
73680     } catch (std::exception& e) {
73681       {
73682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73683       };
73684     } catch (...) {
73685       {
73686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73687       };
73688     }
73689   }
73690   return jresult;
73691 }
73692
73693
73694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73695   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73696   Dali::Toolkit::ScrollBar::Direction arg2 ;
73697
73698   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73699   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73700   {
73701     try {
73702       (arg1)->SetScrollDirection(arg2);
73703     } catch (std::out_of_range& e) {
73704       {
73705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73706       };
73707     } catch (std::exception& e) {
73708       {
73709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73710       };
73711     } catch (Dali::DaliException e) {
73712       {
73713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73714       };
73715     } catch (...) {
73716       {
73717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73718       };
73719     }
73720   }
73721
73722 }
73723
73724
73725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73726   int jresult ;
73727   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73728   Dali::Toolkit::ScrollBar::Direction result;
73729
73730   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73731   {
73732     try {
73733       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73734     } catch (std::out_of_range& e) {
73735       {
73736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73737       };
73738     } catch (std::exception& e) {
73739       {
73740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73741       };
73742     } catch (Dali::DaliException e) {
73743       {
73744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73745       };
73746     } catch (...) {
73747       {
73748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73749       };
73750     }
73751   }
73752
73753   jresult = (int)result;
73754   return jresult;
73755 }
73756
73757
73758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73759   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73760   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73761
73762   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73763   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73764   {
73765     try {
73766       (arg1)->SetIndicatorHeightPolicy(arg2);
73767     } catch (std::out_of_range& e) {
73768       {
73769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73770       };
73771     } catch (std::exception& e) {
73772       {
73773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73774       };
73775     } catch (Dali::DaliException e) {
73776       {
73777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73778       };
73779     } catch (...) {
73780       {
73781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73782       };
73783     }
73784   }
73785
73786 }
73787
73788
73789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73790   int jresult ;
73791   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73792   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73793
73794   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73795   {
73796     try {
73797       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73798     } catch (std::out_of_range& e) {
73799       {
73800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73801       };
73802     } catch (std::exception& e) {
73803       {
73804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73805       };
73806     } catch (Dali::DaliException e) {
73807       {
73808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73809       };
73810     } catch (...) {
73811       {
73812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73813       };
73814     }
73815   }
73816
73817   jresult = (int)result;
73818   return jresult;
73819 }
73820
73821
73822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73823   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73824   float arg2 ;
73825
73826   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73827   arg2 = (float)jarg2;
73828   {
73829     try {
73830       (arg1)->SetIndicatorFixedHeight(arg2);
73831     } catch (std::out_of_range& e) {
73832       {
73833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73834       };
73835     } catch (std::exception& e) {
73836       {
73837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73838       };
73839     } catch (Dali::DaliException e) {
73840       {
73841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73842       };
73843     } catch (...) {
73844       {
73845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73846       };
73847     }
73848   }
73849
73850 }
73851
73852
73853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73854   float jresult ;
73855   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73856   float result;
73857
73858   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73859   {
73860     try {
73861       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73862     } catch (std::out_of_range& e) {
73863       {
73864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73865       };
73866     } catch (std::exception& e) {
73867       {
73868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73869       };
73870     } catch (Dali::DaliException e) {
73871       {
73872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73873       };
73874     } catch (...) {
73875       {
73876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73877       };
73878     }
73879   }
73880
73881   jresult = result;
73882   return jresult;
73883 }
73884
73885
73886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73887   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73888   float arg2 ;
73889
73890   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73891   arg2 = (float)jarg2;
73892   {
73893     try {
73894       (arg1)->SetIndicatorShowDuration(arg2);
73895     } catch (std::out_of_range& e) {
73896       {
73897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73898       };
73899     } catch (std::exception& e) {
73900       {
73901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73902       };
73903     } catch (Dali::DaliException e) {
73904       {
73905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73906       };
73907     } catch (...) {
73908       {
73909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73910       };
73911     }
73912   }
73913
73914 }
73915
73916
73917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73918   float jresult ;
73919   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73920   float result;
73921
73922   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73923   {
73924     try {
73925       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73926     } catch (std::out_of_range& e) {
73927       {
73928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73929       };
73930     } catch (std::exception& e) {
73931       {
73932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73933       };
73934     } catch (Dali::DaliException e) {
73935       {
73936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73937       };
73938     } catch (...) {
73939       {
73940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73941       };
73942     }
73943   }
73944
73945   jresult = result;
73946   return jresult;
73947 }
73948
73949
73950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73951   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73952   float arg2 ;
73953
73954   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73955   arg2 = (float)jarg2;
73956   {
73957     try {
73958       (arg1)->SetIndicatorHideDuration(arg2);
73959     } catch (std::out_of_range& e) {
73960       {
73961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73962       };
73963     } catch (std::exception& e) {
73964       {
73965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73966       };
73967     } catch (Dali::DaliException e) {
73968       {
73969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73970       };
73971     } catch (...) {
73972       {
73973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73974       };
73975     }
73976   }
73977
73978 }
73979
73980
73981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73982   float jresult ;
73983   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73984   float result;
73985
73986   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73987   {
73988     try {
73989       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73990     } catch (std::out_of_range& e) {
73991       {
73992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73993       };
73994     } catch (std::exception& e) {
73995       {
73996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73997       };
73998     } catch (Dali::DaliException e) {
73999       {
74000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74001       };
74002     } catch (...) {
74003       {
74004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74005       };
74006     }
74007   }
74008
74009   jresult = result;
74010   return jresult;
74011 }
74012
74013
74014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
74015   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74016
74017   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74018   {
74019     try {
74020       (arg1)->ShowIndicator();
74021     } catch (std::out_of_range& e) {
74022       {
74023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74024       };
74025     } catch (std::exception& e) {
74026       {
74027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74028       };
74029     } catch (Dali::DaliException e) {
74030       {
74031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74032       };
74033     } catch (...) {
74034       {
74035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74036       };
74037     }
74038   }
74039
74040 }
74041
74042
74043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
74044   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74045
74046   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74047   {
74048     try {
74049       (arg1)->HideIndicator();
74050     } catch (std::out_of_range& e) {
74051       {
74052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74053       };
74054     } catch (std::exception& e) {
74055       {
74056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74057       };
74058     } catch (Dali::DaliException e) {
74059       {
74060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74061       };
74062     } catch (...) {
74063       {
74064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74065       };
74066     }
74067   }
74068
74069 }
74070
74071
74072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
74073   void * jresult ;
74074   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74075   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
74076
74077   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74078   {
74079     try {
74080       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
74081     } catch (std::out_of_range& e) {
74082       {
74083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74084       };
74085     } catch (std::exception& e) {
74086       {
74087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74088       };
74089     } catch (Dali::DaliException e) {
74090       {
74091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74092       };
74093     } catch (...) {
74094       {
74095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74096       };
74097     }
74098   }
74099
74100   jresult = (void *)result;
74101   return jresult;
74102 }
74103
74104
74105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
74106   void * jresult ;
74107   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74108   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
74109
74110   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74111   {
74112     try {
74113       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
74114     } catch (std::out_of_range& e) {
74115       {
74116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74117       };
74118     } catch (std::exception& e) {
74119       {
74120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74121       };
74122     } catch (Dali::DaliException e) {
74123       {
74124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74125       };
74126     } catch (...) {
74127       {
74128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74129       };
74130     }
74131   }
74132
74133   jresult = (void *)result;
74134   return jresult;
74135 }
74136
74137
74138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
74139   int jresult ;
74140   int result;
74141
74142   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
74143   jresult = (int)result;
74144   return jresult;
74145 }
74146
74147
74148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74149   int jresult ;
74150   int result;
74151
74152   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74153   jresult = (int)result;
74154   return jresult;
74155 }
74156
74157
74158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74159   int jresult ;
74160   int result;
74161
74162   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74163   jresult = (int)result;
74164   return jresult;
74165 }
74166
74167
74168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74169   int jresult ;
74170   int result;
74171
74172   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74173   jresult = (int)result;
74174   return jresult;
74175 }
74176
74177
74178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74179   int jresult ;
74180   int result;
74181
74182   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74183   jresult = (int)result;
74184   return jresult;
74185 }
74186
74187
74188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74189   int jresult ;
74190   int result;
74191
74192   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74193   jresult = (int)result;
74194   return jresult;
74195 }
74196
74197
74198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74199   int jresult ;
74200   int result;
74201
74202   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74203   jresult = (int)result;
74204   return jresult;
74205 }
74206
74207
74208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74209   int jresult ;
74210   int result;
74211
74212   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74213   jresult = (int)result;
74214   return jresult;
74215 }
74216
74217
74218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74219   int jresult ;
74220   int result;
74221
74222   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74223   jresult = (int)result;
74224   return jresult;
74225 }
74226
74227
74228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74229   int jresult ;
74230   int result;
74231
74232   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74233   jresult = (int)result;
74234   return jresult;
74235 }
74236
74237
74238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74239   int jresult ;
74240   int result;
74241
74242   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74243   jresult = (int)result;
74244   return jresult;
74245 }
74246
74247
74248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74249   int jresult ;
74250   int result;
74251
74252   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74253   jresult = (int)result;
74254   return jresult;
74255 }
74256
74257
74258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74259   int jresult ;
74260   int result;
74261
74262   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74263   jresult = (int)result;
74264   return jresult;
74265 }
74266
74267
74268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74269   int jresult ;
74270   int result;
74271
74272   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74273   jresult = (int)result;
74274   return jresult;
74275 }
74276
74277
74278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74279   void * jresult ;
74280   Dali::Toolkit::Scrollable::Property *result = 0 ;
74281
74282   {
74283     try {
74284       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
74285     } catch (std::out_of_range& e) {
74286       {
74287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74288       };
74289     } catch (std::exception& e) {
74290       {
74291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74292       };
74293     } catch (Dali::DaliException e) {
74294       {
74295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74296       };
74297     } catch (...) {
74298       {
74299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74300       };
74301     }
74302   }
74303
74304   jresult = (void *)result;
74305   return jresult;
74306 }
74307
74308
74309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74310   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74311
74312   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74313   {
74314     try {
74315       delete arg1;
74316     } catch (std::out_of_range& e) {
74317       {
74318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74319       };
74320     } catch (std::exception& e) {
74321       {
74322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74323       };
74324     } catch (Dali::DaliException e) {
74325       {
74326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74327       };
74328     } catch (...) {
74329       {
74330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74331       };
74332     }
74333   }
74334
74335 }
74336
74337
74338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74339   void * jresult ;
74340   Dali::Toolkit::Scrollable *result = 0 ;
74341
74342   {
74343     try {
74344       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74345     } catch (std::out_of_range& e) {
74346       {
74347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74348       };
74349     } catch (std::exception& e) {
74350       {
74351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74352       };
74353     } catch (Dali::DaliException e) {
74354       {
74355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74356       };
74357     } catch (...) {
74358       {
74359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74360       };
74361     }
74362   }
74363
74364   jresult = (void *)result;
74365   return jresult;
74366 }
74367
74368
74369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74370   void * jresult ;
74371   Dali::Toolkit::Scrollable *arg1 = 0 ;
74372   Dali::Toolkit::Scrollable *result = 0 ;
74373
74374   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74375   if (!arg1) {
74376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74377     return 0;
74378   }
74379   {
74380     try {
74381       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74382     } catch (std::out_of_range& e) {
74383       {
74384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74385       };
74386     } catch (std::exception& e) {
74387       {
74388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74389       };
74390     } catch (Dali::DaliException e) {
74391       {
74392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74393       };
74394     } catch (...) {
74395       {
74396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74397       };
74398     }
74399   }
74400
74401   jresult = (void *)result;
74402   return jresult;
74403 }
74404
74405
74406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74407   void * jresult ;
74408   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74409   Dali::Toolkit::Scrollable *arg2 = 0 ;
74410   Dali::Toolkit::Scrollable *result = 0 ;
74411
74412   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74413   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74414   if (!arg2) {
74415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74416     return 0;
74417   }
74418   {
74419     try {
74420       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74421     } catch (std::out_of_range& e) {
74422       {
74423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74424       };
74425     } catch (std::exception& e) {
74426       {
74427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74428       };
74429     } catch (Dali::DaliException e) {
74430       {
74431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74432       };
74433     } catch (...) {
74434       {
74435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74436       };
74437     }
74438   }
74439
74440   jresult = (void *)result;
74441   return jresult;
74442 }
74443
74444
74445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74446   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74447
74448   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74449   {
74450     try {
74451       delete arg1;
74452     } catch (std::out_of_range& e) {
74453       {
74454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74455       };
74456     } catch (std::exception& e) {
74457       {
74458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74459       };
74460     } catch (Dali::DaliException e) {
74461       {
74462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74463       };
74464     } catch (...) {
74465       {
74466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74467       };
74468     }
74469   }
74470
74471 }
74472
74473
74474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74475   void * jresult ;
74476   Dali::BaseHandle arg1 ;
74477   Dali::BaseHandle *argp1 ;
74478   Dali::Toolkit::Scrollable result;
74479
74480   argp1 = (Dali::BaseHandle *)jarg1;
74481   if (!argp1) {
74482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74483     return 0;
74484   }
74485   arg1 = *argp1;
74486   {
74487     try {
74488       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74489     } catch (std::out_of_range& e) {
74490       {
74491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74492       };
74493     } catch (std::exception& e) {
74494       {
74495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74496       };
74497     } catch (Dali::DaliException e) {
74498       {
74499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74500       };
74501     } catch (...) {
74502       {
74503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74504       };
74505     }
74506   }
74507
74508   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74509   return jresult;
74510 }
74511
74512
74513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74514   unsigned int jresult ;
74515   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74516   bool result;
74517
74518   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74519   {
74520     try {
74521       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74522     } catch (std::out_of_range& e) {
74523       {
74524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74525       };
74526     } catch (std::exception& e) {
74527       {
74528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74529       };
74530     } catch (Dali::DaliException e) {
74531       {
74532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74533       };
74534     } catch (...) {
74535       {
74536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74537       };
74538     }
74539   }
74540
74541   jresult = result;
74542   return jresult;
74543 }
74544
74545
74546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74547   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74548   bool arg2 ;
74549
74550   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74551   arg2 = jarg2 ? true : false;
74552   {
74553     try {
74554       (arg1)->SetOvershootEnabled(arg2);
74555     } catch (std::out_of_range& e) {
74556       {
74557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74558       };
74559     } catch (std::exception& e) {
74560       {
74561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74562       };
74563     } catch (Dali::DaliException e) {
74564       {
74565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74566       };
74567     } catch (...) {
74568       {
74569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74570       };
74571     }
74572   }
74573
74574 }
74575
74576
74577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74578   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74579   Dali::Vector4 *arg2 = 0 ;
74580
74581   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74582   arg2 = (Dali::Vector4 *)jarg2;
74583   if (!arg2) {
74584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74585     return ;
74586   }
74587   {
74588     try {
74589       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74590     } catch (std::out_of_range& e) {
74591       {
74592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74593       };
74594     } catch (std::exception& e) {
74595       {
74596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74597       };
74598     } catch (Dali::DaliException e) {
74599       {
74600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74601       };
74602     } catch (...) {
74603       {
74604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74605       };
74606     }
74607   }
74608
74609 }
74610
74611
74612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74613   void * jresult ;
74614   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74615   Dali::Vector4 result;
74616
74617   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74618   {
74619     try {
74620       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74621     } catch (std::out_of_range& e) {
74622       {
74623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74624       };
74625     } catch (std::exception& e) {
74626       {
74627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74628       };
74629     } catch (Dali::DaliException e) {
74630       {
74631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74632       };
74633     } catch (...) {
74634       {
74635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74636       };
74637     }
74638   }
74639
74640   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74641   return jresult;
74642 }
74643
74644
74645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74646   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74647   float arg2 ;
74648
74649   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74650   arg2 = (float)jarg2;
74651   {
74652     try {
74653       (arg1)->SetOvershootAnimationSpeed(arg2);
74654     } catch (std::out_of_range& e) {
74655       {
74656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74657       };
74658     } catch (std::exception& e) {
74659       {
74660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74661       };
74662     } catch (Dali::DaliException e) {
74663       {
74664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74665       };
74666     } catch (...) {
74667       {
74668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74669       };
74670     }
74671   }
74672
74673 }
74674
74675
74676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74677   float jresult ;
74678   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74679   float result;
74680
74681   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74682   {
74683     try {
74684       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74685     } catch (std::out_of_range& e) {
74686       {
74687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74688       };
74689     } catch (std::exception& e) {
74690       {
74691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74692       };
74693     } catch (Dali::DaliException e) {
74694       {
74695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74696       };
74697     } catch (...) {
74698       {
74699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74700       };
74701     }
74702   }
74703
74704   jresult = result;
74705   return jresult;
74706 }
74707
74708
74709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74710   void * jresult ;
74711   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74712   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74713
74714   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74715   {
74716     try {
74717       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74718     } catch (std::out_of_range& e) {
74719       {
74720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74721       };
74722     } catch (std::exception& e) {
74723       {
74724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74725       };
74726     } catch (Dali::DaliException e) {
74727       {
74728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74729       };
74730     } catch (...) {
74731       {
74732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74733       };
74734     }
74735   }
74736
74737   jresult = (void *)result;
74738   return jresult;
74739 }
74740
74741
74742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74743   void * jresult ;
74744   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74745   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74746
74747   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74748   {
74749     try {
74750       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74751     } catch (std::out_of_range& e) {
74752       {
74753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74754       };
74755     } catch (std::exception& e) {
74756       {
74757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74758       };
74759     } catch (Dali::DaliException e) {
74760       {
74761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74762       };
74763     } catch (...) {
74764       {
74765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74766       };
74767     }
74768   }
74769
74770   jresult = (void *)result;
74771   return jresult;
74772 }
74773
74774
74775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74776   void * jresult ;
74777   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74778   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74779
74780   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74781   {
74782     try {
74783       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74784     } catch (std::out_of_range& e) {
74785       {
74786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74787       };
74788     } catch (std::exception& e) {
74789       {
74790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74791       };
74792     } catch (Dali::DaliException e) {
74793       {
74794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74795       };
74796     } catch (...) {
74797       {
74798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74799       };
74800     }
74801   }
74802
74803   jresult = (void *)result;
74804   return jresult;
74805 }
74806
74807
74808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74809   unsigned int jresult ;
74810   Dali::Toolkit::ControlOrientation::Type arg1 ;
74811   bool result;
74812
74813   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74814   {
74815     try {
74816       result = (bool)Dali::Toolkit::IsVertical(arg1);
74817     } catch (std::out_of_range& e) {
74818       {
74819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74820       };
74821     } catch (std::exception& e) {
74822       {
74823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74824       };
74825     } catch (Dali::DaliException e) {
74826       {
74827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74828       };
74829     } catch (...) {
74830       {
74831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74832       };
74833     }
74834   }
74835
74836   jresult = result;
74837   return jresult;
74838 }
74839
74840
74841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74842   unsigned int jresult ;
74843   Dali::Toolkit::ControlOrientation::Type arg1 ;
74844   bool result;
74845
74846   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74847   {
74848     try {
74849       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74850     } catch (std::out_of_range& e) {
74851       {
74852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74853       };
74854     } catch (std::exception& e) {
74855       {
74856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74857       };
74858     } catch (Dali::DaliException e) {
74859       {
74860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74861       };
74862     } catch (...) {
74863       {
74864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74865       };
74866     }
74867   }
74868
74869   jresult = result;
74870   return jresult;
74871 }
74872
74873
74874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74875   void * jresult ;
74876   unsigned int arg1 ;
74877   unsigned int arg2 ;
74878   Dali::Toolkit::ItemRange *result = 0 ;
74879
74880   arg1 = (unsigned int)jarg1;
74881   arg2 = (unsigned int)jarg2;
74882   {
74883     try {
74884       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74885     } catch (std::out_of_range& e) {
74886       {
74887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74888       };
74889     } catch (std::exception& e) {
74890       {
74891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74892       };
74893     } catch (Dali::DaliException e) {
74894       {
74895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74896       };
74897     } catch (...) {
74898       {
74899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74900       };
74901     }
74902   }
74903
74904   jresult = (void *)result;
74905   return jresult;
74906 }
74907
74908
74909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74910   void * jresult ;
74911   Dali::Toolkit::ItemRange *arg1 = 0 ;
74912   Dali::Toolkit::ItemRange *result = 0 ;
74913
74914   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74915   if (!arg1) {
74916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74917     return 0;
74918   }
74919   {
74920     try {
74921       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74922     } catch (std::out_of_range& e) {
74923       {
74924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74925       };
74926     } catch (std::exception& e) {
74927       {
74928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74929       };
74930     } catch (Dali::DaliException e) {
74931       {
74932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74933       };
74934     } catch (...) {
74935       {
74936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74937       };
74938     }
74939   }
74940
74941   jresult = (void *)result;
74942   return jresult;
74943 }
74944
74945
74946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74947   void * jresult ;
74948   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74949   Dali::Toolkit::ItemRange *arg2 = 0 ;
74950   Dali::Toolkit::ItemRange *result = 0 ;
74951
74952   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74953   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74954   if (!arg2) {
74955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74956     return 0;
74957   }
74958   {
74959     try {
74960       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74961     } catch (std::out_of_range& e) {
74962       {
74963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74964       };
74965     } catch (std::exception& e) {
74966       {
74967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74968       };
74969     } catch (Dali::DaliException e) {
74970       {
74971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74972       };
74973     } catch (...) {
74974       {
74975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74976       };
74977     }
74978   }
74979
74980   jresult = (void *)result;
74981   return jresult;
74982 }
74983
74984
74985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74986   unsigned int jresult ;
74987   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74988   unsigned int arg2 ;
74989   bool result;
74990
74991   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74992   arg2 = (unsigned int)jarg2;
74993   {
74994     try {
74995       result = (bool)(arg1)->Within(arg2);
74996     } catch (std::out_of_range& e) {
74997       {
74998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74999       };
75000     } catch (std::exception& e) {
75001       {
75002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75003       };
75004     } catch (Dali::DaliException e) {
75005       {
75006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75007       };
75008     } catch (...) {
75009       {
75010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75011       };
75012     }
75013   }
75014
75015   jresult = result;
75016   return jresult;
75017 }
75018
75019
75020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
75021   void * jresult ;
75022   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75023   Dali::Toolkit::ItemRange *arg2 = 0 ;
75024   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75025
75026   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75027   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
75028   if (!arg2) {
75029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
75030     return 0;
75031   }
75032   {
75033     try {
75034       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
75035     } catch (std::out_of_range& e) {
75036       {
75037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75038       };
75039     } catch (std::exception& e) {
75040       {
75041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75042       };
75043     } catch (Dali::DaliException e) {
75044       {
75045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75046       };
75047     } catch (...) {
75048       {
75049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75050       };
75051     }
75052   }
75053
75054   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75055   return jresult;
75056 }
75057
75058
75059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
75060   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75061   unsigned int arg2 ;
75062
75063   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75064   arg2 = (unsigned int)jarg2;
75065   if (arg1) (arg1)->begin = arg2;
75066 }
75067
75068
75069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
75070   unsigned int jresult ;
75071   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75072   unsigned int result;
75073
75074   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75075   result = (unsigned int) ((arg1)->begin);
75076   jresult = result;
75077   return jresult;
75078 }
75079
75080
75081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
75082   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75083   unsigned int arg2 ;
75084
75085   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75086   arg2 = (unsigned int)jarg2;
75087   if (arg1) (arg1)->end = arg2;
75088 }
75089
75090
75091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
75092   unsigned int jresult ;
75093   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75094   unsigned int result;
75095
75096   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75097   result = (unsigned int) ((arg1)->end);
75098   jresult = result;
75099   return jresult;
75100 }
75101
75102
75103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
75104   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75105
75106   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75107   {
75108     try {
75109       delete arg1;
75110     } catch (std::out_of_range& e) {
75111       {
75112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75113       };
75114     } catch (std::exception& e) {
75115       {
75116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75117       };
75118     } catch (Dali::DaliException e) {
75119       {
75120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75121       };
75122     } catch (...) {
75123       {
75124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75125       };
75126     }
75127   }
75128
75129 }
75130
75131
75132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
75133   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75134
75135   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75136   {
75137     try {
75138       delete arg1;
75139     } catch (std::out_of_range& e) {
75140       {
75141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75142       };
75143     } catch (std::exception& e) {
75144       {
75145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75146       };
75147     } catch (Dali::DaliException e) {
75148       {
75149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75150       };
75151     } catch (...) {
75152       {
75153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75154       };
75155     }
75156   }
75157
75158 }
75159
75160
75161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75162   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75163   Dali::Toolkit::ControlOrientation::Type arg2 ;
75164
75165   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75166   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75167   {
75168     try {
75169       (arg1)->SetOrientation(arg2);
75170     } catch (std::out_of_range& e) {
75171       {
75172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75173       };
75174     } catch (std::exception& e) {
75175       {
75176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75177       };
75178     } catch (Dali::DaliException e) {
75179       {
75180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75181       };
75182     } catch (...) {
75183       {
75184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75185       };
75186     }
75187   }
75188
75189 }
75190
75191
75192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75193   int jresult ;
75194   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75195   Dali::Toolkit::ControlOrientation::Type result;
75196
75197   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75198   {
75199     try {
75200       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75201     } catch (std::out_of_range& e) {
75202       {
75203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75204       };
75205     } catch (std::exception& e) {
75206       {
75207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75208       };
75209     } catch (Dali::DaliException e) {
75210       {
75211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75212       };
75213     } catch (...) {
75214       {
75215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75216       };
75217     }
75218   }
75219
75220   jresult = (int)result;
75221   return jresult;
75222 }
75223
75224
75225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75226   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75227   Dali::Property::Map *arg2 = 0 ;
75228
75229   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75230   arg2 = (Dali::Property::Map *)jarg2;
75231   if (!arg2) {
75232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75233     return ;
75234   }
75235   {
75236     try {
75237       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75238     } catch (std::out_of_range& e) {
75239       {
75240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75241       };
75242     } catch (std::exception& e) {
75243       {
75244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75245       };
75246     } catch (Dali::DaliException e) {
75247       {
75248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75249       };
75250     } catch (...) {
75251       {
75252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75253       };
75254     }
75255   }
75256
75257 }
75258
75259
75260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75261   void * jresult ;
75262   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75263   Dali::Property::Map result;
75264
75265   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75266   {
75267     try {
75268       result = (arg1)->GetLayoutProperties();
75269     } catch (std::out_of_range& e) {
75270       {
75271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75272       };
75273     } catch (std::exception& e) {
75274       {
75275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75276       };
75277     } catch (Dali::DaliException e) {
75278       {
75279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75280       };
75281     } catch (...) {
75282       {
75283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75284       };
75285     }
75286   }
75287
75288   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75289   return jresult;
75290 }
75291
75292
75293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75294   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75295   unsigned int arg2 ;
75296   Dali::Vector3 *arg3 = 0 ;
75297   Dali::Vector3 *arg4 = 0 ;
75298
75299   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75300   arg2 = (unsigned int)jarg2;
75301   arg3 = (Dali::Vector3 *)jarg3;
75302   if (!arg3) {
75303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75304     return ;
75305   }
75306   arg4 = (Dali::Vector3 *)jarg4;
75307   if (!arg4) {
75308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75309     return ;
75310   }
75311   {
75312     try {
75313       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75314     } catch (std::out_of_range& e) {
75315       {
75316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75317       };
75318     } catch (std::exception& e) {
75319       {
75320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75321       };
75322     } catch (Dali::DaliException e) {
75323       {
75324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75325       };
75326     } catch (...) {
75327       {
75328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75329       };
75330     }
75331   }
75332
75333 }
75334
75335
75336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75337   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75338   Dali::Vector3 *arg2 = 0 ;
75339
75340   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75341   arg2 = (Dali::Vector3 *)jarg2;
75342   if (!arg2) {
75343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75344     return ;
75345   }
75346   {
75347     try {
75348       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75349     } catch (std::out_of_range& e) {
75350       {
75351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75352       };
75353     } catch (std::exception& e) {
75354       {
75355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75356       };
75357     } catch (Dali::DaliException e) {
75358       {
75359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75360       };
75361     } catch (...) {
75362       {
75363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75364       };
75365     }
75366   }
75367
75368 }
75369
75370
75371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75372   float jresult ;
75373   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75374   unsigned int arg2 ;
75375   Dali::Vector3 arg3 ;
75376   Dali::Vector3 *argp3 ;
75377   float result;
75378
75379   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75380   arg2 = (unsigned int)jarg2;
75381   argp3 = (Dali::Vector3 *)jarg3;
75382   if (!argp3) {
75383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75384     return 0;
75385   }
75386   arg3 = *argp3;
75387   {
75388     try {
75389       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75390     } catch (std::out_of_range& e) {
75391       {
75392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75393       };
75394     } catch (std::exception& e) {
75395       {
75396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75397       };
75398     } catch (Dali::DaliException e) {
75399       {
75400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75401       };
75402     } catch (...) {
75403       {
75404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75405       };
75406     }
75407   }
75408
75409   jresult = result;
75410   return jresult;
75411 }
75412
75413
75414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75415   float jresult ;
75416   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75417   float arg2 ;
75418   float result;
75419
75420   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75421   arg2 = (float)jarg2;
75422   {
75423     try {
75424       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75425     } catch (std::out_of_range& e) {
75426       {
75427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75428       };
75429     } catch (std::exception& e) {
75430       {
75431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75432       };
75433     } catch (Dali::DaliException e) {
75434       {
75435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75436       };
75437     } catch (...) {
75438       {
75439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75440       };
75441     }
75442   }
75443
75444   jresult = result;
75445   return jresult;
75446 }
75447
75448
75449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75450   float jresult ;
75451   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75452   unsigned int arg2 ;
75453   float result;
75454
75455   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75456   arg2 = (unsigned int)jarg2;
75457   {
75458     try {
75459       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75460     } catch (std::out_of_range& e) {
75461       {
75462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75463       };
75464     } catch (std::exception& e) {
75465       {
75466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75467       };
75468     } catch (Dali::DaliException e) {
75469       {
75470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75471       };
75472     } catch (...) {
75473       {
75474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75475       };
75476     }
75477   }
75478
75479   jresult = result;
75480   return jresult;
75481 }
75482
75483
75484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75485   void * jresult ;
75486   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75487   float arg2 ;
75488   Dali::Vector3 arg3 ;
75489   Dali::Vector3 *argp3 ;
75490   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75491
75492   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75493   arg2 = (float)jarg2;
75494   argp3 = (Dali::Vector3 *)jarg3;
75495   if (!argp3) {
75496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75497     return 0;
75498   }
75499   arg3 = *argp3;
75500   {
75501     try {
75502       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75503     } catch (std::out_of_range& e) {
75504       {
75505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75506       };
75507     } catch (std::exception& e) {
75508       {
75509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75510       };
75511     } catch (Dali::DaliException e) {
75512       {
75513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75514       };
75515     } catch (...) {
75516       {
75517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75518       };
75519     }
75520   }
75521
75522   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75523   return jresult;
75524 }
75525
75526
75527 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75528   float jresult ;
75529   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75530   int arg2 ;
75531   float arg3 ;
75532   Dali::Vector3 *arg4 = 0 ;
75533   float result;
75534
75535   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75536   arg2 = (int)jarg2;
75537   arg3 = (float)jarg3;
75538   arg4 = (Dali::Vector3 *)jarg4;
75539   if (!arg4) {
75540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75541     return 0;
75542   }
75543   {
75544     try {
75545       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75546     } catch (std::out_of_range& e) {
75547       {
75548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75549       };
75550     } catch (std::exception& e) {
75551       {
75552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75553       };
75554     } catch (Dali::DaliException e) {
75555       {
75556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75557       };
75558     } catch (...) {
75559       {
75560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75561       };
75562     }
75563   }
75564
75565   jresult = result;
75566   return jresult;
75567 }
75568
75569
75570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75571   unsigned int jresult ;
75572   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75573   Dali::Vector3 arg2 ;
75574   Dali::Vector3 *argp2 ;
75575   unsigned int result;
75576
75577   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75578   argp2 = (Dali::Vector3 *)jarg2;
75579   if (!argp2) {
75580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75581     return 0;
75582   }
75583   arg2 = *argp2;
75584   {
75585     try {
75586       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75587     } catch (std::out_of_range& e) {
75588       {
75589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75590       };
75591     } catch (std::exception& e) {
75592       {
75593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75594       };
75595     } catch (Dali::DaliException e) {
75596       {
75597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75598       };
75599     } catch (...) {
75600       {
75601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75602       };
75603     }
75604   }
75605
75606   jresult = result;
75607   return jresult;
75608 }
75609
75610
75611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75612   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75613   unsigned int arg2 ;
75614   Dali::Vector3 *arg3 = 0 ;
75615   Dali::Vector3 *arg4 = 0 ;
75616
75617   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75618   arg2 = (unsigned int)jarg2;
75619   arg3 = (Dali::Vector3 *)jarg3;
75620   if (!arg3) {
75621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75622     return ;
75623   }
75624   arg4 = (Dali::Vector3 *)jarg4;
75625   if (!arg4) {
75626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75627     return ;
75628   }
75629   {
75630     try {
75631       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
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_ItemLayout_GetScrollDirection(void * jarg1) {
75655   void * jresult ;
75656   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75657   Dali::Degree result;
75658
75659   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75660   {
75661     try {
75662       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75663     } catch (std::out_of_range& e) {
75664       {
75665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75666       };
75667     } catch (std::exception& e) {
75668       {
75669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75670       };
75671     } catch (Dali::DaliException e) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75674       };
75675     } catch (...) {
75676       {
75677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75678       };
75679     }
75680   }
75681
75682   jresult = new Dali::Degree((const Dali::Degree &)result);
75683   return jresult;
75684 }
75685
75686
75687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75688   float jresult ;
75689   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75690   float result;
75691
75692   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75693   {
75694     try {
75695       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75696     } catch (std::out_of_range& e) {
75697       {
75698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75699       };
75700     } catch (std::exception& e) {
75701       {
75702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75703       };
75704     } catch (Dali::DaliException e) {
75705       {
75706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75707       };
75708     } catch (...) {
75709       {
75710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75711       };
75712     }
75713   }
75714
75715   jresult = result;
75716   return jresult;
75717 }
75718
75719
75720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75721   float jresult ;
75722   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75723   float result;
75724
75725   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75726   {
75727     try {
75728       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75729     } catch (std::out_of_range& e) {
75730       {
75731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75732       };
75733     } catch (std::exception& e) {
75734       {
75735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75736       };
75737     } catch (Dali::DaliException e) {
75738       {
75739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75740       };
75741     } catch (...) {
75742       {
75743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75744       };
75745     }
75746   }
75747
75748   jresult = result;
75749   return jresult;
75750 }
75751
75752
75753 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75754   float jresult ;
75755   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75756   float result;
75757
75758   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75759   {
75760     try {
75761       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75762     } catch (std::out_of_range& e) {
75763       {
75764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75765       };
75766     } catch (std::exception& e) {
75767       {
75768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75769       };
75770     } catch (Dali::DaliException e) {
75771       {
75772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75773       };
75774     } catch (...) {
75775       {
75776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75777       };
75778     }
75779   }
75780
75781   jresult = result;
75782   return jresult;
75783 }
75784
75785
75786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75787   int jresult ;
75788   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75789   int arg2 ;
75790   int arg3 ;
75791   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75792   bool arg5 ;
75793   int result;
75794
75795   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75796   arg2 = (int)jarg2;
75797   arg3 = (int)jarg3;
75798   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75799   arg5 = jarg5 ? true : false;
75800   {
75801     try {
75802       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
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 = result;
75823   return jresult;
75824 }
75825
75826
75827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75828   float jresult ;
75829   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75830   float result;
75831
75832   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75833   {
75834     try {
75835       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75836     } catch (std::out_of_range& e) {
75837       {
75838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75839       };
75840     } catch (std::exception& e) {
75841       {
75842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75843       };
75844     } catch (Dali::DaliException e) {
75845       {
75846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75847       };
75848     } catch (...) {
75849       {
75850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75851       };
75852     }
75853   }
75854
75855   jresult = result;
75856   return jresult;
75857 }
75858
75859
75860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75861   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75862   Dali::Actor *arg2 = 0 ;
75863   int arg3 ;
75864   Dali::Vector3 *arg4 = 0 ;
75865   Dali::Actor *arg5 = 0 ;
75866
75867   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75868   arg2 = (Dali::Actor *)jarg2;
75869   if (!arg2) {
75870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75871     return ;
75872   }
75873   arg3 = (int)jarg3;
75874   arg4 = (Dali::Vector3 *)jarg4;
75875   if (!arg4) {
75876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75877     return ;
75878   }
75879   arg5 = (Dali::Actor *)jarg5;
75880   if (!arg5) {
75881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75882     return ;
75883   }
75884   {
75885     try {
75886       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75887     } catch (std::out_of_range& e) {
75888       {
75889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75890       };
75891     } catch (std::exception& e) {
75892       {
75893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75894       };
75895     } catch (Dali::DaliException e) {
75896       {
75897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75898       };
75899     } catch (...) {
75900       {
75901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75902       };
75903     }
75904   }
75905
75906 }
75907
75908
75909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75910   void * jresult ;
75911   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75912   int arg2 ;
75913   float arg3 ;
75914   Dali::Vector3 *arg4 = 0 ;
75915   Dali::Vector3 result;
75916
75917   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75918   arg2 = (int)jarg2;
75919   arg3 = (float)jarg3;
75920   arg4 = (Dali::Vector3 *)jarg4;
75921   if (!arg4) {
75922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75923     return 0;
75924   }
75925   {
75926     try {
75927       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75928     } catch (std::out_of_range& e) {
75929       {
75930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75931       };
75932     } catch (std::exception& e) {
75933       {
75934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75935       };
75936     } catch (Dali::DaliException e) {
75937       {
75938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75939       };
75940     } catch (...) {
75941       {
75942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75943       };
75944     }
75945   }
75946
75947   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75948   return jresult;
75949 }
75950
75951
75952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75953   void * jresult ;
75954   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75955   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75956
75957   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75958   {
75959     try {
75960       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75961     } catch (std::out_of_range& e) {
75962       {
75963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75964       };
75965     } catch (std::exception& e) {
75966       {
75967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75968       };
75969     } catch (Dali::DaliException e) {
75970       {
75971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75972       };
75973     } catch (...) {
75974       {
75975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75976       };
75977     }
75978   }
75979
75980   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75981   return jresult;
75982 }
75983
75984
75985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75986   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75987
75988   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75989   {
75990     try {
75991       delete arg1;
75992     } catch (std::out_of_range& e) {
75993       {
75994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75995       };
75996     } catch (std::exception& e) {
75997       {
75998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75999       };
76000     } catch (Dali::DaliException e) {
76001       {
76002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76003       };
76004     } catch (...) {
76005       {
76006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76007       };
76008     }
76009   }
76010
76011 }
76012
76013
76014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
76015   unsigned int jresult ;
76016   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76017   unsigned int result;
76018
76019   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76020   {
76021     try {
76022       result = (unsigned int)(arg1)->GetNumberOfItems();
76023     } catch (std::out_of_range& e) {
76024       {
76025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76026       };
76027     } catch (std::exception& e) {
76028       {
76029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76030       };
76031     } catch (Dali::DaliException e) {
76032       {
76033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76034       };
76035     } catch (...) {
76036       {
76037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76038       };
76039     }
76040   }
76041
76042   jresult = result;
76043   return jresult;
76044 }
76045
76046
76047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
76048   void * jresult ;
76049   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76050   unsigned int arg2 ;
76051   Dali::Actor result;
76052
76053   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76054   arg2 = (unsigned int)jarg2;
76055   {
76056     try {
76057       result = (arg1)->NewItem(arg2);
76058     } catch (std::out_of_range& e) {
76059       {
76060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76061       };
76062     } catch (std::exception& e) {
76063       {
76064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76065       };
76066     } catch (Dali::DaliException e) {
76067       {
76068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76069       };
76070     } catch (...) {
76071       {
76072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76073       };
76074     }
76075   }
76076
76077   jresult = new Dali::Actor((const Dali::Actor &)result);
76078   return jresult;
76079 }
76080
76081
76082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
76083   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76084   unsigned int arg2 ;
76085   Dali::Actor arg3 ;
76086   Dali::Actor *argp3 ;
76087
76088   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76089   arg2 = (unsigned int)jarg2;
76090   argp3 = (Dali::Actor *)jarg3;
76091   if (!argp3) {
76092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76093     return ;
76094   }
76095   arg3 = *argp3;
76096   {
76097     try {
76098       (arg1)->ItemReleased(arg2,arg3);
76099     } catch (std::out_of_range& e) {
76100       {
76101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76102       };
76103     } catch (std::exception& e) {
76104       {
76105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76106       };
76107     } catch (Dali::DaliException e) {
76108       {
76109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76110       };
76111     } catch (...) {
76112       {
76113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76114       };
76115     }
76116   }
76117
76118 }
76119
76120
76121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
76122   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76123   unsigned int arg2 ;
76124   Dali::Actor arg3 ;
76125   Dali::Actor *argp3 ;
76126
76127   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76128   arg2 = (unsigned int)jarg2;
76129   argp3 = (Dali::Actor *)jarg3;
76130   if (!argp3) {
76131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76132     return ;
76133   }
76134   arg3 = *argp3;
76135   {
76136     try {
76137       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
76138     } catch (std::out_of_range& e) {
76139       {
76140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76141       };
76142     } catch (std::exception& e) {
76143       {
76144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76145       };
76146     } catch (Dali::DaliException e) {
76147       {
76148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76149       };
76150     } catch (...) {
76151       {
76152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76153       };
76154     }
76155   }
76156
76157 }
76158
76159
76160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76161   void * jresult ;
76162   Dali::Toolkit::ItemFactory *result = 0 ;
76163
76164   {
76165     try {
76166       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76167     } catch (std::out_of_range& e) {
76168       {
76169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76170       };
76171     } catch (std::exception& e) {
76172       {
76173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76174       };
76175     } catch (Dali::DaliException e) {
76176       {
76177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76178       };
76179     } catch (...) {
76180       {
76181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76182       };
76183     }
76184   }
76185
76186   jresult = (void *)result;
76187   return jresult;
76188 }
76189
76190
76191 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) {
76192   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76193   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76194   if (director) {
76195     director->swig_connect_director(callback0, callback1, callback2);
76196   }
76197 }
76198
76199
76200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76201   int jresult ;
76202   int result;
76203
76204   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76205   jresult = (int)result;
76206   return jresult;
76207 }
76208
76209
76210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76211   int jresult ;
76212   int result;
76213
76214   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76215   jresult = (int)result;
76216   return jresult;
76217 }
76218
76219
76220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76221   int jresult ;
76222   int result;
76223
76224   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76225   jresult = (int)result;
76226   return jresult;
76227 }
76228
76229
76230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76231   int jresult ;
76232   int result;
76233
76234   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76235   jresult = (int)result;
76236   return jresult;
76237 }
76238
76239
76240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76241   int jresult ;
76242   int result;
76243
76244   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76245   jresult = (int)result;
76246   return jresult;
76247 }
76248
76249
76250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76251   int jresult ;
76252   int result;
76253
76254   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76255   jresult = (int)result;
76256   return jresult;
76257 }
76258
76259
76260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76261   int jresult ;
76262   int result;
76263
76264   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76265   jresult = (int)result;
76266   return jresult;
76267 }
76268
76269
76270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76271   int jresult ;
76272   int result;
76273
76274   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76275   jresult = (int)result;
76276   return jresult;
76277 }
76278
76279
76280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76281   int jresult ;
76282   int result;
76283
76284   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76285   jresult = (int)result;
76286   return jresult;
76287 }
76288
76289
76290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76291   int jresult ;
76292   int result;
76293
76294   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76295   jresult = (int)result;
76296   return jresult;
76297 }
76298
76299
76300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76301   int jresult ;
76302   int result;
76303
76304   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76305   jresult = (int)result;
76306   return jresult;
76307 }
76308
76309
76310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76311   void * jresult ;
76312   Dali::Toolkit::ItemView::Property *result = 0 ;
76313
76314   {
76315     try {
76316       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76317     } catch (std::out_of_range& e) {
76318       {
76319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76320       };
76321     } catch (std::exception& e) {
76322       {
76323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76324       };
76325     } catch (Dali::DaliException e) {
76326       {
76327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76328       };
76329     } catch (...) {
76330       {
76331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76332       };
76333     }
76334   }
76335
76336   jresult = (void *)result;
76337   return jresult;
76338 }
76339
76340
76341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76342   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76343
76344   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76345   {
76346     try {
76347       delete arg1;
76348     } catch (std::out_of_range& e) {
76349       {
76350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76351       };
76352     } catch (std::exception& e) {
76353       {
76354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76355       };
76356     } catch (Dali::DaliException e) {
76357       {
76358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76359       };
76360     } catch (...) {
76361       {
76362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76363       };
76364     }
76365   }
76366
76367 }
76368
76369
76370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76371   void * jresult ;
76372   Dali::Toolkit::ItemView *result = 0 ;
76373
76374   {
76375     try {
76376       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76377     } catch (std::out_of_range& e) {
76378       {
76379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76380       };
76381     } catch (std::exception& e) {
76382       {
76383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76384       };
76385     } catch (Dali::DaliException e) {
76386       {
76387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76388       };
76389     } catch (...) {
76390       {
76391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76392       };
76393     }
76394   }
76395
76396   jresult = (void *)result;
76397   return jresult;
76398 }
76399
76400
76401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76402   void * jresult ;
76403   Dali::Toolkit::ItemView *arg1 = 0 ;
76404   Dali::Toolkit::ItemView *result = 0 ;
76405
76406   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76407   if (!arg1) {
76408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76409     return 0;
76410   }
76411   {
76412     try {
76413       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76414     } catch (std::out_of_range& e) {
76415       {
76416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76417       };
76418     } catch (std::exception& e) {
76419       {
76420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76421       };
76422     } catch (Dali::DaliException e) {
76423       {
76424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76425       };
76426     } catch (...) {
76427       {
76428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76429       };
76430     }
76431   }
76432
76433   jresult = (void *)result;
76434   return jresult;
76435 }
76436
76437
76438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76439   void * jresult ;
76440   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76441   Dali::Toolkit::ItemView *arg2 = 0 ;
76442   Dali::Toolkit::ItemView *result = 0 ;
76443
76444   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76445   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76446   if (!arg2) {
76447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76448     return 0;
76449   }
76450   {
76451     try {
76452       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76453     } catch (std::out_of_range& e) {
76454       {
76455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76456       };
76457     } catch (std::exception& e) {
76458       {
76459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76460       };
76461     } catch (Dali::DaliException e) {
76462       {
76463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76464       };
76465     } catch (...) {
76466       {
76467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76468       };
76469     }
76470   }
76471
76472   jresult = (void *)result;
76473   return jresult;
76474 }
76475
76476
76477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76478   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76479
76480   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76481   {
76482     try {
76483       delete arg1;
76484     } catch (std::out_of_range& e) {
76485       {
76486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76487       };
76488     } catch (std::exception& e) {
76489       {
76490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76491       };
76492     } catch (Dali::DaliException e) {
76493       {
76494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76495       };
76496     } catch (...) {
76497       {
76498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76499       };
76500     }
76501   }
76502
76503 }
76504
76505
76506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76507   void * jresult ;
76508   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76509   Dali::Toolkit::ItemView result;
76510
76511   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76512   if (!arg1) {
76513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76514     return 0;
76515   }
76516   {
76517     try {
76518       result = Dali::Toolkit::ItemView::New(*arg1);
76519     } catch (std::out_of_range& e) {
76520       {
76521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76522       };
76523     } catch (std::exception& e) {
76524       {
76525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76526       };
76527     } catch (Dali::DaliException e) {
76528       {
76529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76530       };
76531     } catch (...) {
76532       {
76533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76534       };
76535     }
76536   }
76537
76538   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76539   return jresult;
76540 }
76541
76542
76543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76544   void * jresult ;
76545   Dali::BaseHandle arg1 ;
76546   Dali::BaseHandle *argp1 ;
76547   Dali::Toolkit::ItemView result;
76548
76549   argp1 = (Dali::BaseHandle *)jarg1;
76550   if (!argp1) {
76551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76552     return 0;
76553   }
76554   arg1 = *argp1;
76555   {
76556     try {
76557       result = Dali::Toolkit::ItemView::DownCast(arg1);
76558     } catch (std::out_of_range& e) {
76559       {
76560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76561       };
76562     } catch (std::exception& e) {
76563       {
76564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76565       };
76566     } catch (Dali::DaliException e) {
76567       {
76568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76569       };
76570     } catch (...) {
76571       {
76572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76573       };
76574     }
76575   }
76576
76577   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76578   return jresult;
76579 }
76580
76581
76582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76583   unsigned int jresult ;
76584   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76585   unsigned int result;
76586
76587   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76588   {
76589     try {
76590       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76591     } catch (std::out_of_range& e) {
76592       {
76593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76594       };
76595     } catch (std::exception& e) {
76596       {
76597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76598       };
76599     } catch (Dali::DaliException e) {
76600       {
76601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76602       };
76603     } catch (...) {
76604       {
76605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76606       };
76607     }
76608   }
76609
76610   jresult = result;
76611   return jresult;
76612 }
76613
76614
76615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76616   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76617   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76618
76619   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76620   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76621   if (!arg2) {
76622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76623     return ;
76624   }
76625   {
76626     try {
76627       (arg1)->AddLayout(*arg2);
76628     } catch (std::out_of_range& e) {
76629       {
76630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76631       };
76632     } catch (std::exception& e) {
76633       {
76634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76635       };
76636     } catch (Dali::DaliException e) {
76637       {
76638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76639       };
76640     } catch (...) {
76641       {
76642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76643       };
76644     }
76645   }
76646
76647 }
76648
76649
76650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76651   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76652   unsigned int arg2 ;
76653
76654   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76655   arg2 = (unsigned int)jarg2;
76656   {
76657     try {
76658       (arg1)->RemoveLayout(arg2);
76659     } catch (std::out_of_range& e) {
76660       {
76661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76662       };
76663     } catch (std::exception& e) {
76664       {
76665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76666       };
76667     } catch (Dali::DaliException e) {
76668       {
76669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76670       };
76671     } catch (...) {
76672       {
76673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76674       };
76675     }
76676   }
76677
76678 }
76679
76680
76681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76682   void * jresult ;
76683   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76684   unsigned int arg2 ;
76685   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76686
76687   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76688   arg2 = (unsigned int)jarg2;
76689   {
76690     try {
76691       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76692     } catch (std::out_of_range& e) {
76693       {
76694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76695       };
76696     } catch (std::exception& e) {
76697       {
76698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76699       };
76700     } catch (Dali::DaliException e) {
76701       {
76702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76703       };
76704     } catch (...) {
76705       {
76706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76707       };
76708     }
76709   }
76710
76711   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76712   return jresult;
76713 }
76714
76715
76716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76717   void * jresult ;
76718   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76719   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76720
76721   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76722   {
76723     try {
76724       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76725     } catch (std::out_of_range& e) {
76726       {
76727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76728       };
76729     } catch (std::exception& e) {
76730       {
76731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76732       };
76733     } catch (Dali::DaliException e) {
76734       {
76735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76736       };
76737     } catch (...) {
76738       {
76739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76740       };
76741     }
76742   }
76743
76744   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76745   return jresult;
76746 }
76747
76748
76749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76750   float jresult ;
76751   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76752   Dali::Toolkit::ItemId arg2 ;
76753   float result;
76754
76755   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76756   arg2 = (Dali::Toolkit::ItemId)jarg2;
76757   {
76758     try {
76759       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76760     } catch (std::out_of_range& e) {
76761       {
76762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76763       };
76764     } catch (std::exception& e) {
76765       {
76766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76767       };
76768     } catch (Dali::DaliException e) {
76769       {
76770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76771       };
76772     } catch (...) {
76773       {
76774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76775       };
76776     }
76777   }
76778
76779   jresult = result;
76780   return jresult;
76781 }
76782
76783
76784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76785   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76786   unsigned int arg2 ;
76787   Dali::Vector3 arg3 ;
76788   float arg4 ;
76789   Dali::Vector3 *argp3 ;
76790
76791   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76792   arg2 = (unsigned int)jarg2;
76793   argp3 = (Dali::Vector3 *)jarg3;
76794   if (!argp3) {
76795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76796     return ;
76797   }
76798   arg3 = *argp3;
76799   arg4 = (float)jarg4;
76800   {
76801     try {
76802       (arg1)->ActivateLayout(arg2,arg3,arg4);
76803     } catch (std::out_of_range& e) {
76804       {
76805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76806       };
76807     } catch (std::exception& e) {
76808       {
76809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76810       };
76811     } catch (Dali::DaliException e) {
76812       {
76813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76814       };
76815     } catch (...) {
76816       {
76817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76818       };
76819     }
76820   }
76821
76822 }
76823
76824
76825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76826   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76827
76828   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76829   {
76830     try {
76831       (arg1)->DeactivateCurrentLayout();
76832     } catch (std::out_of_range& e) {
76833       {
76834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76835       };
76836     } catch (std::exception& e) {
76837       {
76838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76839       };
76840     } catch (Dali::DaliException e) {
76841       {
76842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76843       };
76844     } catch (...) {
76845       {
76846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76847       };
76848     }
76849   }
76850
76851 }
76852
76853
76854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76855   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76856   float arg2 ;
76857
76858   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76859   arg2 = (float)jarg2;
76860   {
76861     try {
76862       (arg1)->SetMinimumSwipeSpeed(arg2);
76863     } catch (std::out_of_range& e) {
76864       {
76865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76866       };
76867     } catch (std::exception& e) {
76868       {
76869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76870       };
76871     } catch (Dali::DaliException e) {
76872       {
76873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76874       };
76875     } catch (...) {
76876       {
76877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76878       };
76879     }
76880   }
76881
76882 }
76883
76884
76885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76886   float jresult ;
76887   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76888   float result;
76889
76890   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76891   {
76892     try {
76893       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76894     } catch (std::out_of_range& e) {
76895       {
76896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76897       };
76898     } catch (std::exception& e) {
76899       {
76900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76901       };
76902     } catch (Dali::DaliException e) {
76903       {
76904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76905       };
76906     } catch (...) {
76907       {
76908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76909       };
76910     }
76911   }
76912
76913   jresult = result;
76914   return jresult;
76915 }
76916
76917
76918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76919   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76920   float arg2 ;
76921
76922   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76923   arg2 = (float)jarg2;
76924   {
76925     try {
76926       (arg1)->SetMinimumSwipeDistance(arg2);
76927     } catch (std::out_of_range& e) {
76928       {
76929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76930       };
76931     } catch (std::exception& e) {
76932       {
76933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76934       };
76935     } catch (Dali::DaliException e) {
76936       {
76937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76938       };
76939     } catch (...) {
76940       {
76941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76942       };
76943     }
76944   }
76945
76946 }
76947
76948
76949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76950   float jresult ;
76951   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76952   float result;
76953
76954   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76955   {
76956     try {
76957       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76958     } catch (std::out_of_range& e) {
76959       {
76960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76961       };
76962     } catch (std::exception& e) {
76963       {
76964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76965       };
76966     } catch (Dali::DaliException e) {
76967       {
76968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76969       };
76970     } catch (...) {
76971       {
76972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76973       };
76974     }
76975   }
76976
76977   jresult = result;
76978   return jresult;
76979 }
76980
76981
76982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76983   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76984   float arg2 ;
76985
76986   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76987   arg2 = (float)jarg2;
76988   {
76989     try {
76990       (arg1)->SetWheelScrollDistanceStep(arg2);
76991     } catch (std::out_of_range& e) {
76992       {
76993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76994       };
76995     } catch (std::exception& e) {
76996       {
76997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76998       };
76999     } catch (Dali::DaliException e) {
77000       {
77001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77002       };
77003     } catch (...) {
77004       {
77005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77006       };
77007     }
77008   }
77009
77010 }
77011
77012
77013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
77014   float jresult ;
77015   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77016   float result;
77017
77018   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77019   {
77020     try {
77021       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
77022     } catch (std::out_of_range& e) {
77023       {
77024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77025       };
77026     } catch (std::exception& e) {
77027       {
77028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77029       };
77030     } catch (Dali::DaliException e) {
77031       {
77032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77033       };
77034     } catch (...) {
77035       {
77036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77037       };
77038     }
77039   }
77040
77041   jresult = result;
77042   return jresult;
77043 }
77044
77045
77046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
77047   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77048   bool arg2 ;
77049
77050   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77051   arg2 = jarg2 ? true : false;
77052   {
77053     try {
77054       (arg1)->SetAnchoring(arg2);
77055     } catch (std::out_of_range& e) {
77056       {
77057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77058       };
77059     } catch (std::exception& e) {
77060       {
77061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77062       };
77063     } catch (Dali::DaliException e) {
77064       {
77065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77066       };
77067     } catch (...) {
77068       {
77069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77070       };
77071     }
77072   }
77073
77074 }
77075
77076 //// ========================= end of part 3 =============================
77077
77078 //// ========================== start part 4 ===============================
77079
77080
77081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
77082   unsigned int jresult ;
77083   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77084   bool result;
77085
77086   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77087   {
77088     try {
77089       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
77090     } catch (std::out_of_range& e) {
77091       {
77092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77093       };
77094     } catch (std::exception& e) {
77095       {
77096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77097       };
77098     } catch (Dali::DaliException e) {
77099       {
77100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77101       };
77102     } catch (...) {
77103       {
77104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77105       };
77106     }
77107   }
77108
77109   jresult = result;
77110   return jresult;
77111 }
77112
77113
77114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
77115   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77116   float arg2 ;
77117
77118   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77119   arg2 = (float)jarg2;
77120   {
77121     try {
77122       (arg1)->SetAnchoringDuration(arg2);
77123     } catch (std::out_of_range& e) {
77124       {
77125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77126       };
77127     } catch (std::exception& e) {
77128       {
77129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77130       };
77131     } catch (Dali::DaliException e) {
77132       {
77133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77134       };
77135     } catch (...) {
77136       {
77137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77138       };
77139     }
77140   }
77141
77142 }
77143
77144
77145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77146   float jresult ;
77147   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77148   float result;
77149
77150   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77151   {
77152     try {
77153       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77154     } catch (std::out_of_range& e) {
77155       {
77156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77157       };
77158     } catch (std::exception& e) {
77159       {
77160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77161       };
77162     } catch (Dali::DaliException e) {
77163       {
77164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77165       };
77166     } catch (...) {
77167       {
77168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77169       };
77170     }
77171   }
77172
77173   jresult = result;
77174   return jresult;
77175 }
77176
77177
77178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77179   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77180   Dali::Toolkit::ItemId arg2 ;
77181   float arg3 ;
77182
77183   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77184   arg2 = (Dali::Toolkit::ItemId)jarg2;
77185   arg3 = (float)jarg3;
77186   {
77187     try {
77188       (arg1)->ScrollToItem(arg2,arg3);
77189     } catch (std::out_of_range& e) {
77190       {
77191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77192       };
77193     } catch (std::exception& e) {
77194       {
77195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77196       };
77197     } catch (Dali::DaliException e) {
77198       {
77199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77200       };
77201     } catch (...) {
77202       {
77203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77204       };
77205     }
77206   }
77207
77208 }
77209
77210
77211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77212   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77213   float arg2 ;
77214
77215   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77216   arg2 = (float)jarg2;
77217   {
77218     try {
77219       (arg1)->SetRefreshInterval(arg2);
77220     } catch (std::out_of_range& e) {
77221       {
77222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77223       };
77224     } catch (std::exception& e) {
77225       {
77226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77227       };
77228     } catch (Dali::DaliException e) {
77229       {
77230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77231       };
77232     } catch (...) {
77233       {
77234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77235       };
77236     }
77237   }
77238
77239 }
77240
77241
77242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77243   float jresult ;
77244   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77245   float result;
77246
77247   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77248   {
77249     try {
77250       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
77251     } catch (std::out_of_range& e) {
77252       {
77253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77254       };
77255     } catch (std::exception& e) {
77256       {
77257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77258       };
77259     } catch (Dali::DaliException e) {
77260       {
77261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77262       };
77263     } catch (...) {
77264       {
77265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77266       };
77267     }
77268   }
77269
77270   jresult = result;
77271   return jresult;
77272 }
77273
77274
77275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77276   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77277
77278   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77279   {
77280     try {
77281       (arg1)->Refresh();
77282     } catch (std::out_of_range& e) {
77283       {
77284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77285       };
77286     } catch (std::exception& e) {
77287       {
77288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77289       };
77290     } catch (Dali::DaliException e) {
77291       {
77292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77293       };
77294     } catch (...) {
77295       {
77296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77297       };
77298     }
77299   }
77300
77301 }
77302
77303
77304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77305   void * jresult ;
77306   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77307   Dali::Toolkit::ItemId arg2 ;
77308   Dali::Actor result;
77309
77310   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77311   arg2 = (Dali::Toolkit::ItemId)jarg2;
77312   {
77313     try {
77314       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77315     } catch (std::out_of_range& e) {
77316       {
77317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77318       };
77319     } catch (std::exception& e) {
77320       {
77321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77322       };
77323     } catch (Dali::DaliException e) {
77324       {
77325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77326       };
77327     } catch (...) {
77328       {
77329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77330       };
77331     }
77332   }
77333
77334   jresult = new Dali::Actor((const Dali::Actor &)result);
77335   return jresult;
77336 }
77337
77338
77339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77340   unsigned int jresult ;
77341   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77342   Dali::Actor arg2 ;
77343   Dali::Actor *argp2 ;
77344   Dali::Toolkit::ItemId result;
77345
77346   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77347   argp2 = (Dali::Actor *)jarg2;
77348   if (!argp2) {
77349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77350     return 0;
77351   }
77352   arg2 = *argp2;
77353   {
77354     try {
77355       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77356     } catch (std::out_of_range& e) {
77357       {
77358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77359       };
77360     } catch (std::exception& e) {
77361       {
77362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77363       };
77364     } catch (Dali::DaliException e) {
77365       {
77366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77367       };
77368     } catch (...) {
77369       {
77370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77371       };
77372     }
77373   }
77374
77375   jresult = result;
77376   return jresult;
77377 }
77378
77379
77380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77381   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77382   Dali::Toolkit::Item arg2 ;
77383   float arg3 ;
77384   Dali::Toolkit::Item *argp2 ;
77385
77386   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77387   argp2 = (Dali::Toolkit::Item *)jarg2;
77388   if (!argp2) {
77389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77390     return ;
77391   }
77392   arg2 = *argp2;
77393   arg3 = (float)jarg3;
77394   {
77395     try {
77396       (arg1)->InsertItem(arg2,arg3);
77397     } catch (std::out_of_range& e) {
77398       {
77399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77400       };
77401     } catch (std::exception& e) {
77402       {
77403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77404       };
77405     } catch (Dali::DaliException e) {
77406       {
77407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77408       };
77409     } catch (...) {
77410       {
77411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77412       };
77413     }
77414   }
77415
77416 }
77417
77418
77419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77420   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77421   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77422   float arg3 ;
77423
77424   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77425   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77426   if (!arg2) {
77427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77428     return ;
77429   }
77430   arg3 = (float)jarg3;
77431   {
77432     try {
77433       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77434     } catch (std::out_of_range& e) {
77435       {
77436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77437       };
77438     } catch (std::exception& e) {
77439       {
77440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77441       };
77442     } catch (Dali::DaliException e) {
77443       {
77444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77445       };
77446     } catch (...) {
77447       {
77448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77449       };
77450     }
77451   }
77452
77453 }
77454
77455
77456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77457   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77458   Dali::Toolkit::ItemId arg2 ;
77459   float arg3 ;
77460
77461   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77462   arg2 = (Dali::Toolkit::ItemId)jarg2;
77463   arg3 = (float)jarg3;
77464   {
77465     try {
77466       (arg1)->RemoveItem(arg2,arg3);
77467     } catch (std::out_of_range& e) {
77468       {
77469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77470       };
77471     } catch (std::exception& e) {
77472       {
77473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77474       };
77475     } catch (Dali::DaliException e) {
77476       {
77477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77478       };
77479     } catch (...) {
77480       {
77481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77482       };
77483     }
77484   }
77485
77486 }
77487
77488
77489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77490   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77491   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77492   float arg3 ;
77493
77494   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77495   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77496   if (!arg2) {
77497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77498     return ;
77499   }
77500   arg3 = (float)jarg3;
77501   {
77502     try {
77503       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77504     } catch (std::out_of_range& e) {
77505       {
77506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77507       };
77508     } catch (std::exception& e) {
77509       {
77510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77511       };
77512     } catch (Dali::DaliException e) {
77513       {
77514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77515       };
77516     } catch (...) {
77517       {
77518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77519       };
77520     }
77521   }
77522
77523 }
77524
77525
77526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77527   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77528   Dali::Toolkit::Item arg2 ;
77529   float arg3 ;
77530   Dali::Toolkit::Item *argp2 ;
77531
77532   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77533   argp2 = (Dali::Toolkit::Item *)jarg2;
77534   if (!argp2) {
77535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77536     return ;
77537   }
77538   arg2 = *argp2;
77539   arg3 = (float)jarg3;
77540   {
77541     try {
77542       (arg1)->ReplaceItem(arg2,arg3);
77543     } catch (std::out_of_range& e) {
77544       {
77545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77546       };
77547     } catch (std::exception& e) {
77548       {
77549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77550       };
77551     } catch (Dali::DaliException e) {
77552       {
77553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77554       };
77555     } catch (...) {
77556       {
77557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77558       };
77559     }
77560   }
77561
77562 }
77563
77564
77565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77566   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77567   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77568   float arg3 ;
77569
77570   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77571   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77572   if (!arg2) {
77573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77574     return ;
77575   }
77576   arg3 = (float)jarg3;
77577   {
77578     try {
77579       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77580     } catch (std::out_of_range& e) {
77581       {
77582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77583       };
77584     } catch (std::exception& e) {
77585       {
77586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77587       };
77588     } catch (Dali::DaliException e) {
77589       {
77590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77591       };
77592     } catch (...) {
77593       {
77594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77595       };
77596     }
77597   }
77598
77599 }
77600
77601
77602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77603   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77604   Dali::Vector3 *arg2 = 0 ;
77605
77606   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77607   arg2 = (Dali::Vector3 *)jarg2;
77608   if (!arg2) {
77609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77610     return ;
77611   }
77612   {
77613     try {
77614       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77615     } catch (std::out_of_range& e) {
77616       {
77617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77618       };
77619     } catch (std::exception& e) {
77620       {
77621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77622       };
77623     } catch (Dali::DaliException e) {
77624       {
77625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77626       };
77627     } catch (...) {
77628       {
77629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77630       };
77631     }
77632   }
77633
77634 }
77635
77636
77637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77638   void * jresult ;
77639   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77640   Dali::Vector3 result;
77641
77642   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77643   {
77644     try {
77645       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77646     } catch (std::out_of_range& e) {
77647       {
77648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77649       };
77650     } catch (std::exception& e) {
77651       {
77652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77653       };
77654     } catch (Dali::DaliException e) {
77655       {
77656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77657       };
77658     } catch (...) {
77659       {
77660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77661       };
77662     }
77663   }
77664
77665   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77666   return jresult;
77667 }
77668
77669
77670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77671   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77672   Dali::Vector3 *arg2 = 0 ;
77673
77674   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77675   arg2 = (Dali::Vector3 *)jarg2;
77676   if (!arg2) {
77677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77678     return ;
77679   }
77680   {
77681     try {
77682       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77683     } catch (std::out_of_range& e) {
77684       {
77685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77686       };
77687     } catch (std::exception& e) {
77688       {
77689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77690       };
77691     } catch (Dali::DaliException e) {
77692       {
77693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77694       };
77695     } catch (...) {
77696       {
77697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77698       };
77699     }
77700   }
77701
77702 }
77703
77704
77705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77706   void * jresult ;
77707   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77708   Dali::Vector3 result;
77709
77710   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77711   {
77712     try {
77713       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77714     } catch (std::out_of_range& e) {
77715       {
77716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77717       };
77718     } catch (std::exception& e) {
77719       {
77720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77721       };
77722     } catch (Dali::DaliException e) {
77723       {
77724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77725       };
77726     } catch (...) {
77727       {
77728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77729       };
77730     }
77731   }
77732
77733   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77734   return jresult;
77735 }
77736
77737
77738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77739   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77740   Dali::Toolkit::ItemRange *arg2 = 0 ;
77741
77742   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77743   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77744   if (!arg2) {
77745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77746     return ;
77747   }
77748   {
77749     try {
77750       (arg1)->GetItemsRange(*arg2);
77751     } catch (std::out_of_range& e) {
77752       {
77753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77754       };
77755     } catch (std::exception& e) {
77756       {
77757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77758       };
77759     } catch (Dali::DaliException e) {
77760       {
77761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77762       };
77763     } catch (...) {
77764       {
77765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77766       };
77767     }
77768   }
77769
77770 }
77771
77772
77773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77774   void * jresult ;
77775   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77776   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77777
77778   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77779   {
77780     try {
77781       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77782     } catch (std::out_of_range& e) {
77783       {
77784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77785       };
77786     } catch (std::exception& e) {
77787       {
77788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77789       };
77790     } catch (Dali::DaliException e) {
77791       {
77792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77793       };
77794     } catch (...) {
77795       {
77796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77797       };
77798     }
77799   }
77800
77801   jresult = (void *)result;
77802   return jresult;
77803 }
77804
77805
77806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77807   Dali::Vector3 *arg1 = 0 ;
77808   PropertyInputContainer *arg2 = 0 ;
77809
77810   arg1 = (Dali::Vector3 *)jarg1;
77811   if (!arg1) {
77812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77813     return ;
77814   }
77815   arg2 = (PropertyInputContainer *)jarg2;
77816   if (!arg2) {
77817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77818     return ;
77819   }
77820   {
77821     try {
77822       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77823     } catch (std::out_of_range& e) {
77824       {
77825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77826       };
77827     } catch (std::exception& e) {
77828       {
77829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77830       };
77831     } catch (Dali::DaliException e) {
77832       {
77833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77834       };
77835     } catch (...) {
77836       {
77837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77838       };
77839     }
77840   }
77841
77842 }
77843
77844
77845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77846   Dali::Vector3 *arg1 = 0 ;
77847   PropertyInputContainer *arg2 = 0 ;
77848
77849   arg1 = (Dali::Vector3 *)jarg1;
77850   if (!arg1) {
77851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77852     return ;
77853   }
77854   arg2 = (PropertyInputContainer *)jarg2;
77855   if (!arg2) {
77856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77857     return ;
77858   }
77859   {
77860     try {
77861       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77862     } catch (std::out_of_range& e) {
77863       {
77864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77865       };
77866     } catch (std::exception& e) {
77867       {
77868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77869       };
77870     } catch (Dali::DaliException e) {
77871       {
77872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77873       };
77874     } catch (...) {
77875       {
77876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77877       };
77878     }
77879   }
77880
77881 }
77882
77883
77884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77885   void * jresult ;
77886   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77887
77888   {
77889     try {
77890       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77891     } catch (std::out_of_range& e) {
77892       {
77893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77894       };
77895     } catch (std::exception& e) {
77896       {
77897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77898       };
77899     } catch (Dali::DaliException e) {
77900       {
77901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77902       };
77903     } catch (...) {
77904       {
77905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77906       };
77907     }
77908   }
77909
77910   jresult = (void *)result;
77911   return jresult;
77912 }
77913
77914
77915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77916   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77917
77918   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77919   {
77920     try {
77921       delete arg1;
77922     } catch (std::out_of_range& e) {
77923       {
77924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77925       };
77926     } catch (std::exception& e) {
77927       {
77928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77929       };
77930     } catch (Dali::DaliException e) {
77931       {
77932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77933       };
77934     } catch (...) {
77935       {
77936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77937       };
77938     }
77939   }
77940
77941 }
77942
77943
77944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77945   void * jresult ;
77946   Dali::Path arg1 ;
77947   Dali::Vector3 *arg2 = 0 ;
77948   Dali::Property::Index arg3 ;
77949   Dali::Vector3 *arg4 = 0 ;
77950   unsigned int arg5 ;
77951   Dali::Path *argp1 ;
77952   Dali::Toolkit::ScrollViewPagePathEffect result;
77953
77954   argp1 = (Dali::Path *)jarg1;
77955   if (!argp1) {
77956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77957     return 0;
77958   }
77959   arg1 = *argp1;
77960   arg2 = (Dali::Vector3 *)jarg2;
77961   if (!arg2) {
77962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77963     return 0;
77964   }
77965   arg3 = (Dali::Property::Index)jarg3;
77966   arg4 = (Dali::Vector3 *)jarg4;
77967   if (!arg4) {
77968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77969     return 0;
77970   }
77971   arg5 = (unsigned int)jarg5;
77972   {
77973     try {
77974       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77975     } catch (std::out_of_range& e) {
77976       {
77977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77978       };
77979     } catch (std::exception& e) {
77980       {
77981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77982       };
77983     } catch (Dali::DaliException e) {
77984       {
77985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77986       };
77987     } catch (...) {
77988       {
77989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77990       };
77991     }
77992   }
77993
77994   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77995   return jresult;
77996 }
77997
77998
77999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
78000   void * jresult ;
78001   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
78002
78003   {
78004     try {
78005       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
78006     } catch (std::out_of_range& e) {
78007       {
78008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78009       };
78010     } catch (std::exception& e) {
78011       {
78012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78013       };
78014     } catch (Dali::DaliException e) {
78015       {
78016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78017       };
78018     } catch (...) {
78019       {
78020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78021       };
78022     }
78023   }
78024
78025   jresult = (void *)result;
78026   return jresult;
78027 }
78028
78029
78030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
78031   void * jresult ;
78032   Dali::BaseHandle arg1 ;
78033   Dali::BaseHandle *argp1 ;
78034   Dali::Toolkit::ScrollViewPagePathEffect result;
78035
78036   argp1 = (Dali::BaseHandle *)jarg1;
78037   if (!argp1) {
78038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78039     return 0;
78040   }
78041   arg1 = *argp1;
78042   {
78043     try {
78044       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
78045     } catch (std::out_of_range& e) {
78046       {
78047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78048       };
78049     } catch (std::exception& e) {
78050       {
78051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78052       };
78053     } catch (Dali::DaliException e) {
78054       {
78055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78056       };
78057     } catch (...) {
78058       {
78059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78060       };
78061     }
78062   }
78063
78064   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
78065   return jresult;
78066 }
78067
78068
78069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
78070   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78071   Dali::Actor arg2 ;
78072   unsigned int arg3 ;
78073   Dali::Actor *argp2 ;
78074
78075   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78076   argp2 = (Dali::Actor *)jarg2;
78077   if (!argp2) {
78078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78079     return ;
78080   }
78081   arg2 = *argp2;
78082   arg3 = (unsigned int)jarg3;
78083   {
78084     try {
78085       (arg1)->ApplyToPage(arg2,arg3);
78086     } catch (std::out_of_range& e) {
78087       {
78088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78089       };
78090     } catch (std::exception& e) {
78091       {
78092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78093       };
78094     } catch (Dali::DaliException e) {
78095       {
78096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78097       };
78098     } catch (...) {
78099       {
78100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78101       };
78102     }
78103   }
78104
78105 }
78106
78107
78108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
78109   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78110
78111   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78112   {
78113     try {
78114       delete arg1;
78115     } catch (std::out_of_range& e) {
78116       {
78117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78118       };
78119     } catch (std::exception& e) {
78120       {
78121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78122       };
78123     } catch (Dali::DaliException e) {
78124       {
78125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78126       };
78127     } catch (...) {
78128       {
78129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78130       };
78131     }
78132   }
78133
78134 }
78135
78136
78137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
78138   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78139   Dali::Toolkit::ClampState arg2 ;
78140
78141   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78142   arg2 = (Dali::Toolkit::ClampState)jarg2;
78143   if (arg1) (arg1)->x = arg2;
78144 }
78145
78146
78147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78148   int jresult ;
78149   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78150   Dali::Toolkit::ClampState result;
78151
78152   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78153   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78154   jresult = (int)result;
78155   return jresult;
78156 }
78157
78158
78159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78160   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78161   Dali::Toolkit::ClampState arg2 ;
78162
78163   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78164   arg2 = (Dali::Toolkit::ClampState)jarg2;
78165   if (arg1) (arg1)->y = arg2;
78166 }
78167
78168
78169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78170   int jresult ;
78171   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78172   Dali::Toolkit::ClampState result;
78173
78174   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78175   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78176   jresult = (int)result;
78177   return jresult;
78178 }
78179
78180
78181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78182   void * jresult ;
78183   Dali::Toolkit::ClampState2D *result = 0 ;
78184
78185   {
78186     try {
78187       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78188     } catch (std::out_of_range& e) {
78189       {
78190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78191       };
78192     } catch (std::exception& e) {
78193       {
78194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78195       };
78196     } catch (Dali::DaliException e) {
78197       {
78198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78199       };
78200     } catch (...) {
78201       {
78202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78203       };
78204     }
78205   }
78206
78207   jresult = (void *)result;
78208   return jresult;
78209 }
78210
78211
78212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78213   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78214
78215   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78216   {
78217     try {
78218       delete arg1;
78219     } catch (std::out_of_range& e) {
78220       {
78221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78222       };
78223     } catch (std::exception& e) {
78224       {
78225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78226       };
78227     } catch (Dali::DaliException e) {
78228       {
78229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78230       };
78231     } catch (...) {
78232       {
78233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78234       };
78235     }
78236   }
78237
78238 }
78239
78240
78241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78242   void * jresult ;
78243   float arg1 ;
78244   float arg2 ;
78245   bool arg3 ;
78246   Dali::Toolkit::RulerDomain *result = 0 ;
78247
78248   arg1 = (float)jarg1;
78249   arg2 = (float)jarg2;
78250   arg3 = jarg3 ? true : false;
78251   {
78252     try {
78253       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
78254     } catch (std::out_of_range& e) {
78255       {
78256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78257       };
78258     } catch (std::exception& e) {
78259       {
78260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78261       };
78262     } catch (Dali::DaliException e) {
78263       {
78264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78265       };
78266     } catch (...) {
78267       {
78268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78269       };
78270     }
78271   }
78272
78273   jresult = (void *)result;
78274   return jresult;
78275 }
78276
78277
78278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78279   void * jresult ;
78280   float arg1 ;
78281   float arg2 ;
78282   Dali::Toolkit::RulerDomain *result = 0 ;
78283
78284   arg1 = (float)jarg1;
78285   arg2 = (float)jarg2;
78286   {
78287     try {
78288       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78289     } catch (std::out_of_range& e) {
78290       {
78291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78292       };
78293     } catch (std::exception& e) {
78294       {
78295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78296       };
78297     } catch (Dali::DaliException e) {
78298       {
78299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78300       };
78301     } catch (...) {
78302       {
78303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78304       };
78305     }
78306   }
78307
78308   jresult = (void *)result;
78309   return jresult;
78310 }
78311
78312
78313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78314   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78315   float arg2 ;
78316
78317   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78318   arg2 = (float)jarg2;
78319   if (arg1) (arg1)->min = arg2;
78320 }
78321
78322
78323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78324   float jresult ;
78325   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78326   float result;
78327
78328   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78329   result = (float) ((arg1)->min);
78330   jresult = result;
78331   return jresult;
78332 }
78333
78334
78335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78336   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78337   float arg2 ;
78338
78339   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78340   arg2 = (float)jarg2;
78341   if (arg1) (arg1)->max = arg2;
78342 }
78343
78344
78345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78346   float jresult ;
78347   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78348   float result;
78349
78350   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78351   result = (float) ((arg1)->max);
78352   jresult = result;
78353   return jresult;
78354 }
78355
78356
78357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78358   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78359   bool arg2 ;
78360
78361   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78362   arg2 = jarg2 ? true : false;
78363   if (arg1) (arg1)->enabled = arg2;
78364 }
78365
78366
78367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78368   unsigned int jresult ;
78369   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78370   bool result;
78371
78372   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78373   result = (bool) ((arg1)->enabled);
78374   jresult = result;
78375   return jresult;
78376 }
78377
78378
78379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78380   float jresult ;
78381   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78382   float arg2 ;
78383   float arg3 ;
78384   float arg4 ;
78385   float result;
78386
78387   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78388   arg2 = (float)jarg2;
78389   arg3 = (float)jarg3;
78390   arg4 = (float)jarg4;
78391   {
78392     try {
78393       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78394     } catch (std::out_of_range& e) {
78395       {
78396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78397       };
78398     } catch (std::exception& e) {
78399       {
78400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78401       };
78402     } catch (Dali::DaliException e) {
78403       {
78404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78405       };
78406     } catch (...) {
78407       {
78408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78409       };
78410     }
78411   }
78412
78413   jresult = result;
78414   return jresult;
78415 }
78416
78417
78418 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78419   float jresult ;
78420   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78421   float arg2 ;
78422   float arg3 ;
78423   float result;
78424
78425   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78426   arg2 = (float)jarg2;
78427   arg3 = (float)jarg3;
78428   {
78429     try {
78430       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78431     } catch (std::out_of_range& e) {
78432       {
78433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78434       };
78435     } catch (std::exception& e) {
78436       {
78437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78438       };
78439     } catch (Dali::DaliException e) {
78440       {
78441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78442       };
78443     } catch (...) {
78444       {
78445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78446       };
78447     }
78448   }
78449
78450   jresult = result;
78451   return jresult;
78452 }
78453
78454
78455 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78456   float jresult ;
78457   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78458   float arg2 ;
78459   float result;
78460
78461   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78462   arg2 = (float)jarg2;
78463   {
78464     try {
78465       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78466     } catch (std::out_of_range& e) {
78467       {
78468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78469       };
78470     } catch (std::exception& e) {
78471       {
78472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78473       };
78474     } catch (Dali::DaliException e) {
78475       {
78476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78477       };
78478     } catch (...) {
78479       {
78480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78481       };
78482     }
78483   }
78484
78485   jresult = result;
78486   return jresult;
78487 }
78488
78489
78490 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78491   float jresult ;
78492   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78493   float arg2 ;
78494   float arg3 ;
78495   float arg4 ;
78496   Dali::Toolkit::ClampState *arg5 = 0 ;
78497   float result;
78498
78499   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78500   arg2 = (float)jarg2;
78501   arg3 = (float)jarg3;
78502   arg4 = (float)jarg4;
78503   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78504   if (!arg5) {
78505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78506     return 0;
78507   }
78508   {
78509     try {
78510       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78511     } catch (std::out_of_range& e) {
78512       {
78513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78514       };
78515     } catch (std::exception& e) {
78516       {
78517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78518       };
78519     } catch (Dali::DaliException e) {
78520       {
78521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78522       };
78523     } catch (...) {
78524       {
78525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78526       };
78527     }
78528   }
78529
78530   jresult = result;
78531   return jresult;
78532 }
78533
78534
78535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78536   float jresult ;
78537   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78538   float result;
78539
78540   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78541   {
78542     try {
78543       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78544     } catch (std::out_of_range& e) {
78545       {
78546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78547       };
78548     } catch (std::exception& e) {
78549       {
78550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78551       };
78552     } catch (Dali::DaliException e) {
78553       {
78554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78555       };
78556     } catch (...) {
78557       {
78558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78559       };
78560     }
78561   }
78562
78563   jresult = result;
78564   return jresult;
78565 }
78566
78567
78568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78569   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78570
78571   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78572   {
78573     try {
78574       delete arg1;
78575     } catch (std::out_of_range& e) {
78576       {
78577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78578       };
78579     } catch (std::exception& e) {
78580       {
78581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78582       };
78583     } catch (Dali::DaliException e) {
78584       {
78585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78586       };
78587     } catch (...) {
78588       {
78589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78590       };
78591     }
78592   }
78593
78594 }
78595
78596
78597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78598   float jresult ;
78599   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78600   float arg2 ;
78601   float arg3 ;
78602   float result;
78603
78604   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78605   arg2 = (float)jarg2;
78606   arg3 = (float)jarg3;
78607   {
78608     try {
78609       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78610     } catch (std::out_of_range& e) {
78611       {
78612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78613       };
78614     } catch (std::exception& e) {
78615       {
78616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78617       };
78618     } catch (Dali::DaliException e) {
78619       {
78620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78621       };
78622     } catch (...) {
78623       {
78624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78625       };
78626     }
78627   }
78628
78629   jresult = result;
78630   return jresult;
78631 }
78632
78633
78634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78635   float jresult ;
78636   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78637   float arg2 ;
78638   float result;
78639
78640   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78641   arg2 = (float)jarg2;
78642   {
78643     try {
78644       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78645     } catch (std::out_of_range& e) {
78646       {
78647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78648       };
78649     } catch (std::exception& e) {
78650       {
78651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78652       };
78653     } catch (Dali::DaliException e) {
78654       {
78655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78656       };
78657     } catch (...) {
78658       {
78659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78660       };
78661     }
78662   }
78663
78664   jresult = result;
78665   return jresult;
78666 }
78667
78668
78669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78670   float jresult ;
78671   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78672   unsigned int arg2 ;
78673   unsigned int *arg3 = 0 ;
78674   bool arg4 ;
78675   float result;
78676
78677   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78678   arg2 = (unsigned int)jarg2;
78679   arg3 = (unsigned int *)jarg3;
78680   arg4 = jarg4 ? true : false;
78681   {
78682     try {
78683       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
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 unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78709   unsigned int jresult ;
78710   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78711   float arg2 ;
78712   bool arg3 ;
78713   unsigned int result;
78714
78715   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78716   arg2 = (float)jarg2;
78717   arg3 = jarg3 ? true : false;
78718   {
78719     try {
78720       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78721     } catch (std::out_of_range& e) {
78722       {
78723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78724       };
78725     } catch (std::exception& e) {
78726       {
78727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78728       };
78729     } catch (Dali::DaliException e) {
78730       {
78731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78732       };
78733     } catch (...) {
78734       {
78735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78736       };
78737     }
78738   }
78739
78740   jresult = result;
78741   return jresult;
78742 }
78743
78744
78745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78746   unsigned int jresult ;
78747   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78748   unsigned int result;
78749
78750   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78751   {
78752     try {
78753       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78754     } catch (std::out_of_range& e) {
78755       {
78756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78757       };
78758     } catch (std::exception& e) {
78759       {
78760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78761       };
78762     } catch (Dali::DaliException e) {
78763       {
78764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78765       };
78766     } catch (...) {
78767       {
78768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78769       };
78770     }
78771   }
78772
78773   jresult = result;
78774   return jresult;
78775 }
78776
78777
78778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78779   int jresult ;
78780   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78781   Dali::Toolkit::Ruler::RulerType result;
78782
78783   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78784   {
78785     try {
78786       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78787     } catch (std::out_of_range& e) {
78788       {
78789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78790       };
78791     } catch (std::exception& e) {
78792       {
78793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78794       };
78795     } catch (Dali::DaliException e) {
78796       {
78797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78798       };
78799     } catch (...) {
78800       {
78801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78802       };
78803     }
78804   }
78805
78806   jresult = (int)result;
78807   return jresult;
78808 }
78809
78810
78811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78812   unsigned int jresult ;
78813   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78814   bool result;
78815
78816   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78817   {
78818     try {
78819       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78820     } catch (std::out_of_range& e) {
78821       {
78822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78823       };
78824     } catch (std::exception& e) {
78825       {
78826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78827       };
78828     } catch (Dali::DaliException e) {
78829       {
78830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78831       };
78832     } catch (...) {
78833       {
78834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78835       };
78836     }
78837   }
78838
78839   jresult = result;
78840   return jresult;
78841 }
78842
78843
78844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78845   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78846
78847   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78848   {
78849     try {
78850       (arg1)->Enable();
78851     } catch (std::out_of_range& e) {
78852       {
78853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78854       };
78855     } catch (std::exception& e) {
78856       {
78857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78858       };
78859     } catch (Dali::DaliException e) {
78860       {
78861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78862       };
78863     } catch (...) {
78864       {
78865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78866       };
78867     }
78868   }
78869
78870 }
78871
78872
78873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78874   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78875
78876   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78877   {
78878     try {
78879       (arg1)->Disable();
78880     } catch (std::out_of_range& e) {
78881       {
78882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78883       };
78884     } catch (std::exception& e) {
78885       {
78886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78887       };
78888     } catch (Dali::DaliException e) {
78889       {
78890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78891       };
78892     } catch (...) {
78893       {
78894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78895       };
78896     }
78897   }
78898
78899 }
78900
78901
78902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78903   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78904   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78905   Dali::Toolkit::RulerDomain *argp2 ;
78906
78907   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78908   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78909   if (!argp2) {
78910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78911     return ;
78912   }
78913   arg2 = *argp2;
78914   {
78915     try {
78916       (arg1)->SetDomain(arg2);
78917     } catch (std::out_of_range& e) {
78918       {
78919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78920       };
78921     } catch (std::exception& e) {
78922       {
78923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78924       };
78925     } catch (Dali::DaliException e) {
78926       {
78927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78928       };
78929     } catch (...) {
78930       {
78931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78932       };
78933     }
78934   }
78935
78936 }
78937
78938
78939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78940   void * jresult ;
78941   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78942   Dali::Toolkit::RulerDomain *result = 0 ;
78943
78944   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78945   {
78946     try {
78947       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78948     } catch (std::out_of_range& e) {
78949       {
78950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78951       };
78952     } catch (std::exception& e) {
78953       {
78954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78955       };
78956     } catch (Dali::DaliException e) {
78957       {
78958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78959       };
78960     } catch (...) {
78961       {
78962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78963       };
78964     }
78965   }
78966
78967   jresult = (void *)result;
78968   return jresult;
78969 }
78970
78971
78972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78973   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78974
78975   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78976   {
78977     try {
78978       (arg1)->DisableDomain();
78979     } catch (std::out_of_range& e) {
78980       {
78981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78982       };
78983     } catch (std::exception& e) {
78984       {
78985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78986       };
78987     } catch (Dali::DaliException e) {
78988       {
78989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78990       };
78991     } catch (...) {
78992       {
78993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78994       };
78995     }
78996   }
78997
78998 }
78999
79000
79001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
79002   float jresult ;
79003   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79004   float arg2 ;
79005   float arg3 ;
79006   float arg4 ;
79007   float result;
79008
79009   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79010   arg2 = (float)jarg2;
79011   arg3 = (float)jarg3;
79012   arg4 = (float)jarg4;
79013   {
79014     try {
79015       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
79016     } catch (std::out_of_range& e) {
79017       {
79018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79019       };
79020     } catch (std::exception& e) {
79021       {
79022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79023       };
79024     } catch (Dali::DaliException e) {
79025       {
79026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79027       };
79028     } catch (...) {
79029       {
79030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79031       };
79032     }
79033   }
79034
79035   jresult = result;
79036   return jresult;
79037 }
79038
79039
79040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
79041   float jresult ;
79042   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79043   float arg2 ;
79044   float arg3 ;
79045   float result;
79046
79047   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79048   arg2 = (float)jarg2;
79049   arg3 = (float)jarg3;
79050   {
79051     try {
79052       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
79053     } catch (std::out_of_range& e) {
79054       {
79055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79056       };
79057     } catch (std::exception& e) {
79058       {
79059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79060       };
79061     } catch (Dali::DaliException e) {
79062       {
79063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79064       };
79065     } catch (...) {
79066       {
79067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79068       };
79069     }
79070   }
79071
79072   jresult = result;
79073   return jresult;
79074 }
79075
79076
79077 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
79078   float jresult ;
79079   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79080   float arg2 ;
79081   float result;
79082
79083   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79084   arg2 = (float)jarg2;
79085   {
79086     try {
79087       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
79088     } catch (std::out_of_range& e) {
79089       {
79090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79091       };
79092     } catch (std::exception& e) {
79093       {
79094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79095       };
79096     } catch (Dali::DaliException e) {
79097       {
79098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79099       };
79100     } catch (...) {
79101       {
79102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79103       };
79104     }
79105   }
79106
79107   jresult = result;
79108   return jresult;
79109 }
79110
79111
79112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
79113   float jresult ;
79114   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79115   float arg2 ;
79116   float arg3 ;
79117   float arg4 ;
79118   Dali::Toolkit::ClampState *arg5 = 0 ;
79119   float result;
79120
79121   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79122   arg2 = (float)jarg2;
79123   arg3 = (float)jarg3;
79124   arg4 = (float)jarg4;
79125   arg5 = (Dali::Toolkit::ClampState *)jarg5;
79126   if (!arg5) {
79127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79128     return 0;
79129   }
79130   {
79131     try {
79132       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
79133     } catch (std::out_of_range& e) {
79134       {
79135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79136       };
79137     } catch (std::exception& e) {
79138       {
79139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79140       };
79141     } catch (Dali::DaliException e) {
79142       {
79143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79144       };
79145     } catch (...) {
79146       {
79147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79148       };
79149     }
79150   }
79151
79152   jresult = result;
79153   return jresult;
79154 }
79155
79156
79157 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79158   float jresult ;
79159   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79160   float arg2 ;
79161   float arg3 ;
79162   float arg4 ;
79163   float arg5 ;
79164   float result;
79165
79166   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79167   arg2 = (float)jarg2;
79168   arg3 = (float)jarg3;
79169   arg4 = (float)jarg4;
79170   arg5 = (float)jarg5;
79171   {
79172     try {
79173       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79174     } catch (std::out_of_range& e) {
79175       {
79176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79177       };
79178     } catch (std::exception& e) {
79179       {
79180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79181       };
79182     } catch (Dali::DaliException e) {
79183       {
79184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79185       };
79186     } catch (...) {
79187       {
79188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79189       };
79190     }
79191   }
79192
79193   jresult = result;
79194   return jresult;
79195 }
79196
79197
79198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79199   float jresult ;
79200   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79201   float arg2 ;
79202   float arg3 ;
79203   float arg4 ;
79204   float result;
79205
79206   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79207   arg2 = (float)jarg2;
79208   arg3 = (float)jarg3;
79209   arg4 = (float)jarg4;
79210   {
79211     try {
79212       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79213     } catch (std::out_of_range& e) {
79214       {
79215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79216       };
79217     } catch (std::exception& e) {
79218       {
79219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79220       };
79221     } catch (Dali::DaliException e) {
79222       {
79223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79224       };
79225     } catch (...) {
79226       {
79227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79228       };
79229     }
79230   }
79231
79232   jresult = result;
79233   return jresult;
79234 }
79235
79236
79237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79238   float jresult ;
79239   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79240   float arg2 ;
79241   float arg3 ;
79242   float result;
79243
79244   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79245   arg2 = (float)jarg2;
79246   arg3 = (float)jarg3;
79247   {
79248     try {
79249       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
79250     } catch (std::out_of_range& e) {
79251       {
79252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79253       };
79254     } catch (std::exception& e) {
79255       {
79256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79257       };
79258     } catch (Dali::DaliException e) {
79259       {
79260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79261       };
79262     } catch (...) {
79263       {
79264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79265       };
79266     }
79267   }
79268
79269   jresult = result;
79270   return jresult;
79271 }
79272
79273
79274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
79275   float jresult ;
79276   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79277   float arg2 ;
79278   float result;
79279
79280   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79281   arg2 = (float)jarg2;
79282   {
79283     try {
79284       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79285     } catch (std::out_of_range& e) {
79286       {
79287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79288       };
79289     } catch (std::exception& e) {
79290       {
79291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79292       };
79293     } catch (Dali::DaliException e) {
79294       {
79295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79296       };
79297     } catch (...) {
79298       {
79299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79300       };
79301     }
79302   }
79303
79304   jresult = result;
79305   return jresult;
79306 }
79307
79308
79309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79310   float jresult ;
79311   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79312   float arg2 ;
79313   float arg3 ;
79314   float arg4 ;
79315   float arg5 ;
79316   Dali::Toolkit::ClampState *arg6 = 0 ;
79317   float result;
79318
79319   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79320   arg2 = (float)jarg2;
79321   arg3 = (float)jarg3;
79322   arg4 = (float)jarg4;
79323   arg5 = (float)jarg5;
79324   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79325   if (!arg6) {
79326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79327     return 0;
79328   }
79329   {
79330     try {
79331       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79332     } catch (std::out_of_range& e) {
79333       {
79334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79335       };
79336     } catch (std::exception& e) {
79337       {
79338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79339       };
79340     } catch (Dali::DaliException e) {
79341       {
79342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79343       };
79344     } catch (...) {
79345       {
79346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79347       };
79348     }
79349   }
79350
79351   jresult = result;
79352   return jresult;
79353 }
79354
79355
79356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79357   void * jresult ;
79358   Dali::Toolkit::DefaultRuler *result = 0 ;
79359
79360   {
79361     try {
79362       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79363     } catch (std::out_of_range& e) {
79364       {
79365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79366       };
79367     } catch (std::exception& e) {
79368       {
79369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79370       };
79371     } catch (Dali::DaliException e) {
79372       {
79373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79374       };
79375     } catch (...) {
79376       {
79377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79378       };
79379     }
79380   }
79381
79382   jresult = (void *)result;
79383   return jresult;
79384 }
79385
79386
79387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79388   float jresult ;
79389   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79390   float arg2 ;
79391   float arg3 ;
79392   float result;
79393
79394   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79395   arg2 = (float)jarg2;
79396   arg3 = (float)jarg3;
79397   {
79398     try {
79399       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79400     } catch (std::out_of_range& e) {
79401       {
79402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79403       };
79404     } catch (std::exception& e) {
79405       {
79406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79407       };
79408     } catch (Dali::DaliException e) {
79409       {
79410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79411       };
79412     } catch (...) {
79413       {
79414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79415       };
79416     }
79417   }
79418
79419   jresult = result;
79420   return jresult;
79421 }
79422
79423
79424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79425   float jresult ;
79426   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79427   unsigned int arg2 ;
79428   unsigned int *arg3 = 0 ;
79429   bool arg4 ;
79430   float result;
79431
79432   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79433   arg2 = (unsigned int)jarg2;
79434   arg3 = (unsigned int *)jarg3;
79435   arg4 = jarg4 ? true : false;
79436   {
79437     try {
79438       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79439     } catch (std::out_of_range& e) {
79440       {
79441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79442       };
79443     } catch (std::exception& e) {
79444       {
79445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79446       };
79447     } catch (Dali::DaliException e) {
79448       {
79449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79450       };
79451     } catch (...) {
79452       {
79453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79454       };
79455     }
79456   }
79457
79458   jresult = result;
79459   return jresult;
79460 }
79461
79462
79463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79464   unsigned int jresult ;
79465   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79466   float arg2 ;
79467   bool arg3 ;
79468   unsigned int result;
79469
79470   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79471   arg2 = (float)jarg2;
79472   arg3 = jarg3 ? true : false;
79473   {
79474     try {
79475       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79476     } catch (std::out_of_range& e) {
79477       {
79478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79479       };
79480     } catch (std::exception& e) {
79481       {
79482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79483       };
79484     } catch (Dali::DaliException e) {
79485       {
79486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79487       };
79488     } catch (...) {
79489       {
79490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79491       };
79492     }
79493   }
79494
79495   jresult = result;
79496   return jresult;
79497 }
79498
79499
79500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79501   unsigned int jresult ;
79502   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79503   unsigned int result;
79504
79505   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79506   {
79507     try {
79508       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79509     } catch (std::out_of_range& e) {
79510       {
79511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79512       };
79513     } catch (std::exception& e) {
79514       {
79515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79516       };
79517     } catch (Dali::DaliException e) {
79518       {
79519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79520       };
79521     } catch (...) {
79522       {
79523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79524       };
79525     }
79526   }
79527
79528   jresult = result;
79529   return jresult;
79530 }
79531
79532
79533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79534   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79535
79536   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79537   {
79538     try {
79539       delete arg1;
79540     } catch (std::out_of_range& e) {
79541       {
79542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79543       };
79544     } catch (std::exception& e) {
79545       {
79546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79547       };
79548     } catch (Dali::DaliException e) {
79549       {
79550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79551       };
79552     } catch (...) {
79553       {
79554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79555       };
79556     }
79557   }
79558
79559 }
79560
79561
79562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79563   void * jresult ;
79564   float arg1 ;
79565   Dali::Toolkit::FixedRuler *result = 0 ;
79566
79567   arg1 = (float)jarg1;
79568   {
79569     try {
79570       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79571     } catch (std::out_of_range& e) {
79572       {
79573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79574       };
79575     } catch (std::exception& e) {
79576       {
79577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79578       };
79579     } catch (Dali::DaliException e) {
79580       {
79581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79582       };
79583     } catch (...) {
79584       {
79585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79586       };
79587     }
79588   }
79589
79590   jresult = (void *)result;
79591   return jresult;
79592 }
79593
79594
79595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79596   void * jresult ;
79597   Dali::Toolkit::FixedRuler *result = 0 ;
79598
79599   {
79600     try {
79601       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79602     } catch (std::out_of_range& e) {
79603       {
79604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79605       };
79606     } catch (std::exception& e) {
79607       {
79608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79609       };
79610     } catch (Dali::DaliException e) {
79611       {
79612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79613       };
79614     } catch (...) {
79615       {
79616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79617       };
79618     }
79619   }
79620
79621   jresult = (void *)result;
79622   return jresult;
79623 }
79624
79625
79626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79627   float jresult ;
79628   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79629   float arg2 ;
79630   float arg3 ;
79631   float result;
79632
79633   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79634   arg2 = (float)jarg2;
79635   arg3 = (float)jarg3;
79636   {
79637     try {
79638       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79639     } catch (std::out_of_range& e) {
79640       {
79641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79642       };
79643     } catch (std::exception& e) {
79644       {
79645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79646       };
79647     } catch (Dali::DaliException e) {
79648       {
79649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79650       };
79651     } catch (...) {
79652       {
79653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79654       };
79655     }
79656   }
79657
79658   jresult = result;
79659   return jresult;
79660 }
79661
79662
79663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79664   float jresult ;
79665   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79666   unsigned int arg2 ;
79667   unsigned int *arg3 = 0 ;
79668   bool arg4 ;
79669   float result;
79670
79671   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79672   arg2 = (unsigned int)jarg2;
79673   arg3 = (unsigned int *)jarg3;
79674   arg4 = jarg4 ? true : false;
79675   {
79676     try {
79677       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79678     } catch (std::out_of_range& e) {
79679       {
79680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79681       };
79682     } catch (std::exception& e) {
79683       {
79684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79685       };
79686     } catch (Dali::DaliException e) {
79687       {
79688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79689       };
79690     } catch (...) {
79691       {
79692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79693       };
79694     }
79695   }
79696
79697   jresult = result;
79698   return jresult;
79699 }
79700
79701
79702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79703   unsigned int jresult ;
79704   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79705   float arg2 ;
79706   bool arg3 ;
79707   unsigned int result;
79708
79709   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79710   arg2 = (float)jarg2;
79711   arg3 = jarg3 ? true : false;
79712   {
79713     try {
79714       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79715     } catch (std::out_of_range& e) {
79716       {
79717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79718       };
79719     } catch (std::exception& e) {
79720       {
79721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79722       };
79723     } catch (Dali::DaliException e) {
79724       {
79725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79726       };
79727     } catch (...) {
79728       {
79729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79730       };
79731     }
79732   }
79733
79734   jresult = result;
79735   return jresult;
79736 }
79737
79738
79739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79740   unsigned int jresult ;
79741   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79742   unsigned int result;
79743
79744   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79745   {
79746     try {
79747       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79748     } catch (std::out_of_range& e) {
79749       {
79750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79751       };
79752     } catch (std::exception& e) {
79753       {
79754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79755       };
79756     } catch (Dali::DaliException e) {
79757       {
79758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79759       };
79760     } catch (...) {
79761       {
79762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79763       };
79764     }
79765   }
79766
79767   jresult = result;
79768   return jresult;
79769 }
79770
79771
79772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79773   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79774
79775   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79776   {
79777     try {
79778       delete arg1;
79779     } catch (std::out_of_range& e) {
79780       {
79781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79782       };
79783     } catch (std::exception& e) {
79784       {
79785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79786       };
79787     } catch (Dali::DaliException e) {
79788       {
79789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79790       };
79791     } catch (...) {
79792       {
79793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79794       };
79795     }
79796   }
79797
79798 }
79799
79800
79801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79802   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79803   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79804
79805   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79806   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79807   if (arg1) (arg1)->scale = *arg2;
79808 }
79809
79810
79811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79812   void * jresult ;
79813   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79814   Dali::Toolkit::ClampState2D *result = 0 ;
79815
79816   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79817   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79818   jresult = (void *)result;
79819   return jresult;
79820 }
79821
79822
79823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79824   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79825   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79826
79827   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79828   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79829   if (arg1) (arg1)->position = *arg2;
79830 }
79831
79832
79833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79834   void * jresult ;
79835   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79836   Dali::Toolkit::ClampState2D *result = 0 ;
79837
79838   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79839   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79840   jresult = (void *)result;
79841   return jresult;
79842 }
79843
79844
79845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79846   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79847   Dali::Toolkit::ClampState arg2 ;
79848
79849   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79850   arg2 = (Dali::Toolkit::ClampState)jarg2;
79851   if (arg1) (arg1)->rotation = arg2;
79852 }
79853
79854
79855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79856   int jresult ;
79857   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79858   Dali::Toolkit::ClampState result;
79859
79860   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79861   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79862   jresult = (int)result;
79863   return jresult;
79864 }
79865
79866
79867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79868   void * jresult ;
79869   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79870
79871   {
79872     try {
79873       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79874     } catch (std::out_of_range& e) {
79875       {
79876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79877       };
79878     } catch (std::exception& e) {
79879       {
79880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79881       };
79882     } catch (Dali::DaliException e) {
79883       {
79884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79885       };
79886     } catch (...) {
79887       {
79888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79889       };
79890     }
79891   }
79892
79893   jresult = (void *)result;
79894   return jresult;
79895 }
79896
79897
79898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79899   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79900
79901   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79902   {
79903     try {
79904       delete arg1;
79905     } catch (std::out_of_range& e) {
79906       {
79907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79908       };
79909     } catch (std::exception& e) {
79910       {
79911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79912       };
79913     } catch (Dali::DaliException e) {
79914       {
79915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79916       };
79917     } catch (...) {
79918       {
79919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79920       };
79921     }
79922   }
79923
79924 }
79925
79926
79927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79928   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79929   Dali::Toolkit::SnapType arg2 ;
79930
79931   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79932   arg2 = (Dali::Toolkit::SnapType)jarg2;
79933   if (arg1) (arg1)->type = arg2;
79934 }
79935
79936
79937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79938   int jresult ;
79939   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79940   Dali::Toolkit::SnapType result;
79941
79942   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79943   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79944   jresult = (int)result;
79945   return jresult;
79946 }
79947
79948
79949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79950   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79951   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79952
79953   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79954   arg2 = (Dali::Vector2 *)jarg2;
79955   if (arg1) (arg1)->position = *arg2;
79956 }
79957
79958
79959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79960   void * jresult ;
79961   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79962   Dali::Vector2 *result = 0 ;
79963
79964   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79965   result = (Dali::Vector2 *)& ((arg1)->position);
79966   jresult = (void *)result;
79967   return jresult;
79968 }
79969
79970
79971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79972   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79973   float arg2 ;
79974
79975   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79976   arg2 = (float)jarg2;
79977   if (arg1) (arg1)->duration = arg2;
79978 }
79979
79980
79981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79982   float jresult ;
79983   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79984   float result;
79985
79986   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79987   result = (float) ((arg1)->duration);
79988   jresult = result;
79989   return jresult;
79990 }
79991
79992
79993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79994   void * jresult ;
79995   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79996
79997   {
79998     try {
79999       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
80000     } catch (std::out_of_range& e) {
80001       {
80002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80003       };
80004     } catch (std::exception& e) {
80005       {
80006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80007       };
80008     } catch (Dali::DaliException e) {
80009       {
80010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80011       };
80012     } catch (...) {
80013       {
80014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80015       };
80016     }
80017   }
80018
80019   jresult = (void *)result;
80020   return jresult;
80021 }
80022
80023
80024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
80025   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80026
80027   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80028   {
80029     try {
80030       delete arg1;
80031     } catch (std::out_of_range& e) {
80032       {
80033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80034       };
80035     } catch (std::exception& e) {
80036       {
80037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80038       };
80039     } catch (Dali::DaliException e) {
80040       {
80041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80042       };
80043     } catch (...) {
80044       {
80045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80046       };
80047     }
80048   }
80049
80050 }
80051
80052
80053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
80054   int jresult ;
80055   int result;
80056
80057   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
80058   jresult = (int)result;
80059   return jresult;
80060 }
80061
80062
80063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
80064   int jresult ;
80065   int result;
80066
80067   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
80068   jresult = (int)result;
80069   return jresult;
80070 }
80071
80072
80073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
80074   int jresult ;
80075   int result;
80076
80077   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
80078   jresult = (int)result;
80079   return jresult;
80080 }
80081
80082
80083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
80084   int jresult ;
80085   int result;
80086
80087   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
80088   jresult = (int)result;
80089   return jresult;
80090 }
80091
80092
80093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
80094   int jresult ;
80095   int result;
80096
80097   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
80098   jresult = (int)result;
80099   return jresult;
80100 }
80101
80102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
80103   int jresult ;
80104   int result;
80105
80106   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
80107   jresult = (int)result;
80108   return jresult;
80109 }
80110
80111
80112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
80113   int jresult ;
80114   int result;
80115
80116   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
80117   jresult = (int)result;
80118   return jresult;
80119 }
80120
80121
80122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
80123   int jresult ;
80124   int result;
80125
80126   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
80127   jresult = (int)result;
80128   return jresult;
80129 }
80130
80131
80132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
80133   int jresult ;
80134   int result;
80135
80136   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
80137   jresult = (int)result;
80138   return jresult;
80139 }
80140
80141
80142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
80143   int jresult ;
80144   int result;
80145
80146   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80147   jresult = (int)result;
80148   return jresult;
80149 }
80150
80151
80152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80153   int jresult ;
80154   int result;
80155
80156   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80157   jresult = (int)result;
80158   return jresult;
80159 }
80160
80161
80162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80163   int jresult ;
80164   int result;
80165
80166   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80167   jresult = (int)result;
80168   return jresult;
80169 }
80170
80171
80172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80173   int jresult ;
80174   int result;
80175
80176   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80177   jresult = (int)result;
80178   return jresult;
80179 }
80180
80181
80182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80183   int jresult ;
80184   int result;
80185
80186   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80187   jresult = (int)result;
80188   return jresult;
80189 }
80190
80191
80192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80193   int jresult ;
80194   int result;
80195
80196   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80197   jresult = (int)result;
80198   return jresult;
80199 }
80200
80201
80202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80203   int jresult ;
80204   int result;
80205
80206   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80207   jresult = (int)result;
80208   return jresult;
80209 }
80210
80211
80212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80213   int jresult ;
80214   int result;
80215
80216   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80217   jresult = (int)result;
80218   return jresult;
80219 }
80220
80221
80222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80223   int jresult ;
80224   int result;
80225
80226   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80227   jresult = (int)result;
80228   return jresult;
80229 }
80230
80231
80232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80233   int jresult ;
80234   int result;
80235
80236   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80237   jresult = (int)result;
80238   return jresult;
80239 }
80240
80241
80242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80243   int jresult ;
80244   int result;
80245
80246   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80247   jresult = (int)result;
80248   return jresult;
80249 }
80250
80251
80252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80253   int jresult ;
80254   int result;
80255
80256   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80257   jresult = (int)result;
80258   return jresult;
80259 }
80260
80261
80262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80263   int jresult ;
80264   int result;
80265
80266   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80267   jresult = (int)result;
80268   return jresult;
80269 }
80270
80271
80272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80273   int jresult ;
80274   int result;
80275
80276   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80277   jresult = (int)result;
80278   return jresult;
80279 }
80280
80281
80282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80283   int jresult ;
80284   int result;
80285
80286   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80287   jresult = (int)result;
80288   return jresult;
80289 }
80290
80291
80292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80293   int jresult ;
80294   int result;
80295
80296   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80297   jresult = (int)result;
80298   return jresult;
80299 }
80300
80301
80302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80303   int jresult ;
80304   int result;
80305
80306   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80307   jresult = (int)result;
80308   return jresult;
80309 }
80310
80311
80312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80313   void * jresult ;
80314   Dali::Toolkit::ScrollView::Property *result = 0 ;
80315
80316   {
80317     try {
80318       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80319     } catch (std::out_of_range& e) {
80320       {
80321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80322       };
80323     } catch (std::exception& e) {
80324       {
80325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80326       };
80327     } catch (Dali::DaliException e) {
80328       {
80329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80330       };
80331     } catch (...) {
80332       {
80333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80334       };
80335     }
80336   }
80337
80338   jresult = (void *)result;
80339   return jresult;
80340 }
80341
80342
80343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80344   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80345
80346   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80347   {
80348     try {
80349       delete arg1;
80350     } catch (std::out_of_range& e) {
80351       {
80352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80353       };
80354     } catch (std::exception& e) {
80355       {
80356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80357       };
80358     } catch (Dali::DaliException e) {
80359       {
80360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80361       };
80362     } catch (...) {
80363       {
80364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80365       };
80366     }
80367   }
80368
80369 }
80370
80371
80372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80373   void * jresult ;
80374   Dali::Toolkit::ScrollView *result = 0 ;
80375
80376   {
80377     try {
80378       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80379     } catch (std::out_of_range& e) {
80380       {
80381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80382       };
80383     } catch (std::exception& e) {
80384       {
80385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80386       };
80387     } catch (Dali::DaliException e) {
80388       {
80389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80390       };
80391     } catch (...) {
80392       {
80393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80394       };
80395     }
80396   }
80397
80398   jresult = (void *)result;
80399   return jresult;
80400 }
80401
80402
80403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80404   void * jresult ;
80405   Dali::Toolkit::ScrollView *arg1 = 0 ;
80406   Dali::Toolkit::ScrollView *result = 0 ;
80407
80408   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80409   if (!arg1) {
80410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80411     return 0;
80412   }
80413   {
80414     try {
80415       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80416     } catch (std::out_of_range& e) {
80417       {
80418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80419       };
80420     } catch (std::exception& e) {
80421       {
80422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80423       };
80424     } catch (Dali::DaliException e) {
80425       {
80426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80427       };
80428     } catch (...) {
80429       {
80430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80431       };
80432     }
80433   }
80434
80435   jresult = (void *)result;
80436   return jresult;
80437 }
80438
80439
80440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80441   void * jresult ;
80442   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80443   Dali::Toolkit::ScrollView *arg2 = 0 ;
80444   Dali::Toolkit::ScrollView *result = 0 ;
80445
80446   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80447   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80448   if (!arg2) {
80449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80450     return 0;
80451   }
80452   {
80453     try {
80454       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80455     } catch (std::out_of_range& e) {
80456       {
80457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80458       };
80459     } catch (std::exception& e) {
80460       {
80461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80462       };
80463     } catch (Dali::DaliException e) {
80464       {
80465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80466       };
80467     } catch (...) {
80468       {
80469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80470       };
80471     }
80472   }
80473
80474   jresult = (void *)result;
80475   return jresult;
80476 }
80477
80478
80479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80480   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80481
80482   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80483   {
80484     try {
80485       delete arg1;
80486     } catch (std::out_of_range& e) {
80487       {
80488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80489       };
80490     } catch (std::exception& e) {
80491       {
80492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80493       };
80494     } catch (Dali::DaliException e) {
80495       {
80496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80497       };
80498     } catch (...) {
80499       {
80500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80501       };
80502     }
80503   }
80504
80505 }
80506
80507
80508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80509   void * jresult ;
80510   Dali::Toolkit::ScrollView result;
80511
80512   {
80513     try {
80514       result = Dali::Toolkit::ScrollView::New();
80515     } catch (std::out_of_range& e) {
80516       {
80517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80518       };
80519     } catch (std::exception& e) {
80520       {
80521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80522       };
80523     } catch (Dali::DaliException e) {
80524       {
80525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80526       };
80527     } catch (...) {
80528       {
80529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80530       };
80531     }
80532   }
80533
80534   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80535   return jresult;
80536 }
80537
80538
80539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80540   void * jresult ;
80541   Dali::BaseHandle arg1 ;
80542   Dali::BaseHandle *argp1 ;
80543   Dali::Toolkit::ScrollView result;
80544
80545   argp1 = (Dali::BaseHandle *)jarg1;
80546   if (!argp1) {
80547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80548     return 0;
80549   }
80550   arg1 = *argp1;
80551   {
80552     try {
80553       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80554     } catch (std::out_of_range& e) {
80555       {
80556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80557       };
80558     } catch (std::exception& e) {
80559       {
80560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80561       };
80562     } catch (Dali::DaliException e) {
80563       {
80564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80565       };
80566     } catch (...) {
80567       {
80568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80569       };
80570     }
80571   }
80572
80573   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80574   return jresult;
80575 }
80576
80577
80578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80579   void * jresult ;
80580   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80581   Dali::AlphaFunction result;
80582
80583   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80584   {
80585     try {
80586       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80587     } catch (std::out_of_range& e) {
80588       {
80589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80590       };
80591     } catch (std::exception& e) {
80592       {
80593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80594       };
80595     } catch (Dali::DaliException e) {
80596       {
80597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80598       };
80599     } catch (...) {
80600       {
80601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80602       };
80603     }
80604   }
80605
80606   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80607   return jresult;
80608 }
80609
80610
80611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80612   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80613   Dali::AlphaFunction arg2 ;
80614   Dali::AlphaFunction *argp2 ;
80615
80616   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80617   argp2 = (Dali::AlphaFunction *)jarg2;
80618   if (!argp2) {
80619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80620     return ;
80621   }
80622   arg2 = *argp2;
80623   {
80624     try {
80625       (arg1)->SetScrollSnapAlphaFunction(arg2);
80626     } catch (std::out_of_range& e) {
80627       {
80628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80629       };
80630     } catch (std::exception& e) {
80631       {
80632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80633       };
80634     } catch (Dali::DaliException e) {
80635       {
80636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80637       };
80638     } catch (...) {
80639       {
80640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80641       };
80642     }
80643   }
80644
80645 }
80646
80647
80648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80649   void * jresult ;
80650   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80651   Dali::AlphaFunction result;
80652
80653   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80654   {
80655     try {
80656       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80657     } catch (std::out_of_range& e) {
80658       {
80659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80660       };
80661     } catch (std::exception& e) {
80662       {
80663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80664       };
80665     } catch (Dali::DaliException e) {
80666       {
80667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80668       };
80669     } catch (...) {
80670       {
80671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80672       };
80673     }
80674   }
80675
80676   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80677   return jresult;
80678 }
80679
80680
80681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80682   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80683   Dali::AlphaFunction arg2 ;
80684   Dali::AlphaFunction *argp2 ;
80685
80686   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80687   argp2 = (Dali::AlphaFunction *)jarg2;
80688   if (!argp2) {
80689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80690     return ;
80691   }
80692   arg2 = *argp2;
80693   {
80694     try {
80695       (arg1)->SetScrollFlickAlphaFunction(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 float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80719   float jresult ;
80720   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80721   float result;
80722
80723   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80724   {
80725     try {
80726       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
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 = result;
80747   return jresult;
80748 }
80749
80750
80751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80752   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80753   float arg2 ;
80754
80755   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80756   arg2 = (float)jarg2;
80757   {
80758     try {
80759       (arg1)->SetScrollSnapDuration(arg2);
80760     } catch (std::out_of_range& e) {
80761       {
80762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80763       };
80764     } catch (std::exception& e) {
80765       {
80766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80767       };
80768     } catch (Dali::DaliException e) {
80769       {
80770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80771       };
80772     } catch (...) {
80773       {
80774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80775       };
80776     }
80777   }
80778
80779 }
80780
80781
80782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80783   float jresult ;
80784   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80785   float result;
80786
80787   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80788   {
80789     try {
80790       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80791     } catch (std::out_of_range& e) {
80792       {
80793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80794       };
80795     } catch (std::exception& e) {
80796       {
80797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80798       };
80799     } catch (Dali::DaliException e) {
80800       {
80801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80802       };
80803     } catch (...) {
80804       {
80805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80806       };
80807     }
80808   }
80809
80810   jresult = result;
80811   return jresult;
80812 }
80813
80814
80815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80816   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80817   float arg2 ;
80818
80819   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80820   arg2 = (float)jarg2;
80821   {
80822     try {
80823       (arg1)->SetScrollFlickDuration(arg2);
80824     } catch (std::out_of_range& e) {
80825       {
80826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80827       };
80828     } catch (std::exception& e) {
80829       {
80830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80831       };
80832     } catch (Dali::DaliException e) {
80833       {
80834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80835       };
80836     } catch (...) {
80837       {
80838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80839       };
80840     }
80841   }
80842
80843 }
80844
80845
80846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80847   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80848   Dali::Toolkit::RulerPtr arg2 ;
80849   Dali::Toolkit::RulerPtr *argp2 ;
80850
80851   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80852   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80853   if (!argp2) {
80854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80855     return ;
80856   }
80857   arg2 = *argp2;
80858   {
80859     try {
80860       (arg1)->SetRulerX(arg2);
80861     } catch (std::out_of_range& e) {
80862       {
80863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80864       };
80865     } catch (std::exception& e) {
80866       {
80867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80868       };
80869     } catch (Dali::DaliException e) {
80870       {
80871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80872       };
80873     } catch (...) {
80874       {
80875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80876       };
80877     }
80878   }
80879
80880 }
80881
80882
80883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80884   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80885   Dali::Toolkit::RulerPtr arg2 ;
80886   Dali::Toolkit::RulerPtr *argp2 ;
80887
80888   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80889   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80890   if (!argp2) {
80891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80892     return ;
80893   }
80894   arg2 = *argp2;
80895   {
80896     try {
80897       (arg1)->SetRulerY(arg2);
80898     } catch (std::out_of_range& e) {
80899       {
80900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80901       };
80902     } catch (std::exception& e) {
80903       {
80904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80905       };
80906     } catch (Dali::DaliException e) {
80907       {
80908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80909       };
80910     } catch (...) {
80911       {
80912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80913       };
80914     }
80915   }
80916
80917 }
80918
80919
80920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80921   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80922   bool arg2 ;
80923
80924   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80925   arg2 = jarg2 ? true : false;
80926   {
80927     try {
80928       (arg1)->SetScrollSensitive(arg2);
80929     } catch (std::out_of_range& e) {
80930       {
80931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80932       };
80933     } catch (std::exception& e) {
80934       {
80935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80936       };
80937     } catch (Dali::DaliException e) {
80938       {
80939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80940       };
80941     } catch (...) {
80942       {
80943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80944       };
80945     }
80946   }
80947
80948 }
80949
80950
80951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80952   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80953   float arg2 ;
80954   float arg3 ;
80955
80956   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80957   arg2 = (float)jarg2;
80958   arg3 = (float)jarg3;
80959   {
80960     try {
80961       (arg1)->SetMaxOvershoot(arg2,arg3);
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_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80985   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80986   Dali::AlphaFunction arg2 ;
80987   Dali::AlphaFunction *argp2 ;
80988
80989   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80990   argp2 = (Dali::AlphaFunction *)jarg2;
80991   if (!argp2) {
80992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80993     return ;
80994   }
80995   arg2 = *argp2;
80996   {
80997     try {
80998       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80999     } catch (std::out_of_range& e) {
81000       {
81001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81002       };
81003     } catch (std::exception& e) {
81004       {
81005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81006       };
81007     } catch (Dali::DaliException e) {
81008       {
81009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81010       };
81011     } catch (...) {
81012       {
81013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81014       };
81015     }
81016   }
81017
81018 }
81019
81020
81021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
81022   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81023   float arg2 ;
81024
81025   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81026   arg2 = (float)jarg2;
81027   {
81028     try {
81029       (arg1)->SetSnapOvershootDuration(arg2);
81030     } catch (std::out_of_range& e) {
81031       {
81032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81033       };
81034     } catch (std::exception& e) {
81035       {
81036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81037       };
81038     } catch (Dali::DaliException e) {
81039       {
81040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81041       };
81042     } catch (...) {
81043       {
81044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81045       };
81046     }
81047   }
81048
81049 }
81050
81051
81052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
81053   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81054   bool arg2 ;
81055
81056   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81057   arg2 = jarg2 ? true : false;
81058   {
81059     try {
81060       (arg1)->SetActorAutoSnap(arg2);
81061     } catch (std::out_of_range& e) {
81062       {
81063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81064       };
81065     } catch (std::exception& e) {
81066       {
81067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81068       };
81069     } catch (Dali::DaliException e) {
81070       {
81071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81072       };
81073     } catch (...) {
81074       {
81075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81076       };
81077     }
81078   }
81079
81080 }
81081
81082
81083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
81084   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81085   bool arg2 ;
81086
81087   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81088   arg2 = jarg2 ? true : false;
81089   {
81090     try {
81091       (arg1)->SetWrapMode(arg2);
81092     } catch (std::out_of_range& e) {
81093       {
81094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81095       };
81096     } catch (std::exception& e) {
81097       {
81098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81099       };
81100     } catch (Dali::DaliException e) {
81101       {
81102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81103       };
81104     } catch (...) {
81105       {
81106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81107       };
81108     }
81109   }
81110
81111 }
81112
81113
81114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
81115   int jresult ;
81116   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81117   int result;
81118
81119   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81120   {
81121     try {
81122       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
81123     } catch (std::out_of_range& e) {
81124       {
81125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81126       };
81127     } catch (std::exception& e) {
81128       {
81129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81130       };
81131     } catch (Dali::DaliException e) {
81132       {
81133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81134       };
81135     } catch (...) {
81136       {
81137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81138       };
81139     }
81140   }
81141
81142   jresult = result;
81143   return jresult;
81144 }
81145
81146
81147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81148   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81149   int arg2 ;
81150
81151   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81152   arg2 = (int)jarg2;
81153   {
81154     try {
81155       (arg1)->SetScrollUpdateDistance(arg2);
81156     } catch (std::out_of_range& e) {
81157       {
81158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81159       };
81160     } catch (std::exception& e) {
81161       {
81162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81163       };
81164     } catch (Dali::DaliException e) {
81165       {
81166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81167       };
81168     } catch (...) {
81169       {
81170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81171       };
81172     }
81173   }
81174
81175 }
81176
81177
81178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81179   unsigned int jresult ;
81180   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81181   bool result;
81182
81183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81184   {
81185     try {
81186       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
81187     } catch (std::out_of_range& e) {
81188       {
81189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81190       };
81191     } catch (std::exception& e) {
81192       {
81193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81194       };
81195     } catch (Dali::DaliException e) {
81196       {
81197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81198       };
81199     } catch (...) {
81200       {
81201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81202       };
81203     }
81204   }
81205
81206   jresult = result;
81207   return jresult;
81208 }
81209
81210
81211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81212   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81213   bool arg2 ;
81214
81215   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81216   arg2 = jarg2 ? true : false;
81217   {
81218     try {
81219       (arg1)->SetAxisAutoLock(arg2);
81220     } catch (std::out_of_range& e) {
81221       {
81222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81223       };
81224     } catch (std::exception& e) {
81225       {
81226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81227       };
81228     } catch (Dali::DaliException e) {
81229       {
81230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81231       };
81232     } catch (...) {
81233       {
81234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81235       };
81236     }
81237   }
81238
81239 }
81240
81241
81242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
81243   float jresult ;
81244   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81245   float result;
81246
81247   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81248   {
81249     try {
81250       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
81251     } catch (std::out_of_range& e) {
81252       {
81253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81254       };
81255     } catch (std::exception& e) {
81256       {
81257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81258       };
81259     } catch (Dali::DaliException e) {
81260       {
81261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81262       };
81263     } catch (...) {
81264       {
81265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81266       };
81267     }
81268   }
81269
81270   jresult = result;
81271   return jresult;
81272 }
81273
81274
81275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
81276   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81277   float arg2 ;
81278
81279   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81280   arg2 = (float)jarg2;
81281   {
81282     try {
81283       (arg1)->SetAxisAutoLockGradient(arg2);
81284     } catch (std::out_of_range& e) {
81285       {
81286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81287       };
81288     } catch (std::exception& e) {
81289       {
81290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81291       };
81292     } catch (Dali::DaliException e) {
81293       {
81294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81295       };
81296     } catch (...) {
81297       {
81298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81299       };
81300     }
81301   }
81302
81303 }
81304
81305
81306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81307   float jresult ;
81308   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81309   float result;
81310
81311   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81312   {
81313     try {
81314       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81315     } catch (std::out_of_range& e) {
81316       {
81317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81318       };
81319     } catch (std::exception& e) {
81320       {
81321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81322       };
81323     } catch (Dali::DaliException e) {
81324       {
81325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81326       };
81327     } catch (...) {
81328       {
81329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81330       };
81331     }
81332   }
81333
81334   jresult = result;
81335   return jresult;
81336 }
81337
81338
81339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81340   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81341   float arg2 ;
81342
81343   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81344   arg2 = (float)jarg2;
81345   {
81346     try {
81347       (arg1)->SetFrictionCoefficient(arg2);
81348     } catch (std::out_of_range& e) {
81349       {
81350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81351       };
81352     } catch (std::exception& e) {
81353       {
81354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81355       };
81356     } catch (Dali::DaliException e) {
81357       {
81358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81359       };
81360     } catch (...) {
81361       {
81362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81363       };
81364     }
81365   }
81366
81367 }
81368
81369
81370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81371   float jresult ;
81372   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81373   float result;
81374
81375   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81376   {
81377     try {
81378       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81379     } catch (std::out_of_range& e) {
81380       {
81381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81382       };
81383     } catch (std::exception& e) {
81384       {
81385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81386       };
81387     } catch (Dali::DaliException e) {
81388       {
81389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81390       };
81391     } catch (...) {
81392       {
81393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81394       };
81395     }
81396   }
81397
81398   jresult = result;
81399   return jresult;
81400 }
81401
81402
81403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81404   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81405   float arg2 ;
81406
81407   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81408   arg2 = (float)jarg2;
81409   {
81410     try {
81411       (arg1)->SetFlickSpeedCoefficient(arg2);
81412     } catch (std::out_of_range& e) {
81413       {
81414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81415       };
81416     } catch (std::exception& e) {
81417       {
81418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81419       };
81420     } catch (Dali::DaliException e) {
81421       {
81422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81423       };
81424     } catch (...) {
81425       {
81426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81427       };
81428     }
81429   }
81430
81431 }
81432
81433
81434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81435   void * jresult ;
81436   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81437   Dali::Vector2 result;
81438
81439   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81440   {
81441     try {
81442       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81443     } catch (std::out_of_range& e) {
81444       {
81445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81446       };
81447     } catch (std::exception& e) {
81448       {
81449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81450       };
81451     } catch (Dali::DaliException e) {
81452       {
81453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81454       };
81455     } catch (...) {
81456       {
81457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81458       };
81459     }
81460   }
81461
81462   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81463   return jresult;
81464 }
81465
81466
81467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81468   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81469   Dali::Vector2 *arg2 = 0 ;
81470
81471   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81472   arg2 = (Dali::Vector2 *)jarg2;
81473   if (!arg2) {
81474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81475     return ;
81476   }
81477   {
81478     try {
81479       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81480     } catch (std::out_of_range& e) {
81481       {
81482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81483       };
81484     } catch (std::exception& e) {
81485       {
81486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81487       };
81488     } catch (Dali::DaliException e) {
81489       {
81490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81491       };
81492     } catch (...) {
81493       {
81494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81495       };
81496     }
81497   }
81498
81499 }
81500
81501
81502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81503   float jresult ;
81504   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81505   float result;
81506
81507   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81508   {
81509     try {
81510       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81511     } catch (std::out_of_range& e) {
81512       {
81513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81514       };
81515     } catch (std::exception& e) {
81516       {
81517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81518       };
81519     } catch (Dali::DaliException e) {
81520       {
81521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81522       };
81523     } catch (...) {
81524       {
81525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81526       };
81527     }
81528   }
81529
81530   jresult = result;
81531   return jresult;
81532 }
81533
81534
81535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81536   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81537   float arg2 ;
81538
81539   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81540   arg2 = (float)jarg2;
81541   {
81542     try {
81543       (arg1)->SetMinimumSpeedForFlick(arg2);
81544     } catch (std::out_of_range& e) {
81545       {
81546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81547       };
81548     } catch (std::exception& e) {
81549       {
81550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81551       };
81552     } catch (Dali::DaliException e) {
81553       {
81554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81555       };
81556     } catch (...) {
81557       {
81558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81559       };
81560     }
81561   }
81562
81563 }
81564
81565
81566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81567   float jresult ;
81568   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81569   float result;
81570
81571   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81572   {
81573     try {
81574       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81575     } catch (std::out_of_range& e) {
81576       {
81577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81578       };
81579     } catch (std::exception& e) {
81580       {
81581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81582       };
81583     } catch (Dali::DaliException e) {
81584       {
81585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81586       };
81587     } catch (...) {
81588       {
81589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81590       };
81591     }
81592   }
81593
81594   jresult = result;
81595   return jresult;
81596 }
81597
81598
81599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81600   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81601   float arg2 ;
81602
81603   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81604   arg2 = (float)jarg2;
81605   {
81606     try {
81607       (arg1)->SetMaxFlickSpeed(arg2);
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_GetWheelScrollDistanceStep(void * jarg1) {
81631   void * jresult ;
81632   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81633   Dali::Vector2 result;
81634
81635   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81636   {
81637     try {
81638       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81639     } catch (std::out_of_range& e) {
81640       {
81641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81642       };
81643     } catch (std::exception& e) {
81644       {
81645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81646       };
81647     } catch (Dali::DaliException e) {
81648       {
81649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81650       };
81651     } catch (...) {
81652       {
81653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81654       };
81655     }
81656   }
81657
81658   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81659   return jresult;
81660 }
81661
81662
81663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81664   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81665   Dali::Vector2 arg2 ;
81666   Dali::Vector2 *argp2 ;
81667
81668   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81669   argp2 = (Dali::Vector2 *)jarg2;
81670   if (!argp2) {
81671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81672     return ;
81673   }
81674   arg2 = *argp2;
81675   {
81676     try {
81677       (arg1)->SetWheelScrollDistanceStep(arg2);
81678     } catch (std::out_of_range& e) {
81679       {
81680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81681       };
81682     } catch (std::exception& e) {
81683       {
81684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81685       };
81686     } catch (Dali::DaliException e) {
81687       {
81688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81689       };
81690     } catch (...) {
81691       {
81692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81693       };
81694     }
81695   }
81696
81697 }
81698
81699
81700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81701   void * jresult ;
81702   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81703   Dali::Vector2 result;
81704
81705   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81706   {
81707     try {
81708       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81709     } catch (std::out_of_range& e) {
81710       {
81711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81712       };
81713     } catch (std::exception& e) {
81714       {
81715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81716       };
81717     } catch (Dali::DaliException e) {
81718       {
81719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81720       };
81721     } catch (...) {
81722       {
81723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81724       };
81725     }
81726   }
81727
81728   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81729   return jresult;
81730 }
81731
81732
81733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81734   unsigned int jresult ;
81735   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81736   unsigned int result;
81737
81738   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81739   {
81740     try {
81741       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81742     } catch (std::out_of_range& e) {
81743       {
81744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81745       };
81746     } catch (std::exception& e) {
81747       {
81748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81749       };
81750     } catch (Dali::DaliException e) {
81751       {
81752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81753       };
81754     } catch (...) {
81755       {
81756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81757       };
81758     }
81759   }
81760
81761   jresult = result;
81762   return jresult;
81763 }
81764
81765
81766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81767   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81768   Dali::Vector2 *arg2 = 0 ;
81769
81770   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81771   arg2 = (Dali::Vector2 *)jarg2;
81772   if (!arg2) {
81773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81774     return ;
81775   }
81776   {
81777     try {
81778       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81779     } catch (std::out_of_range& e) {
81780       {
81781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81782       };
81783     } catch (std::exception& e) {
81784       {
81785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81786       };
81787     } catch (Dali::DaliException e) {
81788       {
81789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81790       };
81791     } catch (...) {
81792       {
81793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81794       };
81795     }
81796   }
81797
81798 }
81799
81800
81801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81802   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81803   Dali::Vector2 *arg2 = 0 ;
81804   float arg3 ;
81805
81806   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81807   arg2 = (Dali::Vector2 *)jarg2;
81808   if (!arg2) {
81809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81810     return ;
81811   }
81812   arg3 = (float)jarg3;
81813   {
81814     try {
81815       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81816     } catch (std::out_of_range& e) {
81817       {
81818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81819       };
81820     } catch (std::exception& e) {
81821       {
81822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81823       };
81824     } catch (Dali::DaliException e) {
81825       {
81826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81827       };
81828     } catch (...) {
81829       {
81830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81831       };
81832     }
81833   }
81834
81835 }
81836
81837
81838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81839   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81840   Dali::Vector2 *arg2 = 0 ;
81841   float arg3 ;
81842   Dali::AlphaFunction arg4 ;
81843   Dali::AlphaFunction *argp4 ;
81844
81845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81846   arg2 = (Dali::Vector2 *)jarg2;
81847   if (!arg2) {
81848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81849     return ;
81850   }
81851   arg3 = (float)jarg3;
81852   argp4 = (Dali::AlphaFunction *)jarg4;
81853   if (!argp4) {
81854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81855     return ;
81856   }
81857   arg4 = *argp4;
81858   {
81859     try {
81860       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81861     } catch (std::out_of_range& e) {
81862       {
81863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81864       };
81865     } catch (std::exception& e) {
81866       {
81867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81868       };
81869     } catch (Dali::DaliException e) {
81870       {
81871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81872       };
81873     } catch (...) {
81874       {
81875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81876       };
81877     }
81878   }
81879
81880 }
81881
81882
81883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81884   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81885   Dali::Vector2 *arg2 = 0 ;
81886   float arg3 ;
81887   Dali::Toolkit::DirectionBias arg4 ;
81888   Dali::Toolkit::DirectionBias arg5 ;
81889
81890   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81891   arg2 = (Dali::Vector2 *)jarg2;
81892   if (!arg2) {
81893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81894     return ;
81895   }
81896   arg3 = (float)jarg3;
81897   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81898   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81899   {
81900     try {
81901       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81902     } catch (std::out_of_range& e) {
81903       {
81904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81905       };
81906     } catch (std::exception& e) {
81907       {
81908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81909       };
81910     } catch (Dali::DaliException e) {
81911       {
81912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81913       };
81914     } catch (...) {
81915       {
81916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81917       };
81918     }
81919   }
81920
81921 }
81922
81923
81924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81925   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81926   Dali::Vector2 *arg2 = 0 ;
81927   float arg3 ;
81928   Dali::AlphaFunction arg4 ;
81929   Dali::Toolkit::DirectionBias arg5 ;
81930   Dali::Toolkit::DirectionBias arg6 ;
81931   Dali::AlphaFunction *argp4 ;
81932
81933   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81934   arg2 = (Dali::Vector2 *)jarg2;
81935   if (!arg2) {
81936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81937     return ;
81938   }
81939   arg3 = (float)jarg3;
81940   argp4 = (Dali::AlphaFunction *)jarg4;
81941   if (!argp4) {
81942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81943     return ;
81944   }
81945   arg4 = *argp4;
81946   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81947   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81948   {
81949     try {
81950       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81951     } catch (std::out_of_range& e) {
81952       {
81953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81954       };
81955     } catch (std::exception& e) {
81956       {
81957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81958       };
81959     } catch (Dali::DaliException e) {
81960       {
81961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81962       };
81963     } catch (...) {
81964       {
81965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81966       };
81967     }
81968   }
81969
81970 }
81971
81972
81973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81974   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81975   unsigned int arg2 ;
81976
81977   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81978   arg2 = (unsigned int)jarg2;
81979   {
81980     try {
81981       (arg1)->ScrollTo(arg2);
81982     } catch (std::out_of_range& e) {
81983       {
81984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81985       };
81986     } catch (std::exception& e) {
81987       {
81988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81989       };
81990     } catch (Dali::DaliException e) {
81991       {
81992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81993       };
81994     } catch (...) {
81995       {
81996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81997       };
81998     }
81999   }
82000
82001 }
82002
82003
82004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
82005   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82006   unsigned int arg2 ;
82007   float arg3 ;
82008
82009   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82010   arg2 = (unsigned int)jarg2;
82011   arg3 = (float)jarg3;
82012   {
82013     try {
82014       (arg1)->ScrollTo(arg2,arg3);
82015     } catch (std::out_of_range& e) {
82016       {
82017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82018       };
82019     } catch (std::exception& e) {
82020       {
82021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82022       };
82023     } catch (Dali::DaliException e) {
82024       {
82025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82026       };
82027     } catch (...) {
82028       {
82029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82030       };
82031     }
82032   }
82033
82034 }
82035
82036
82037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
82038   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82039   unsigned int arg2 ;
82040   float arg3 ;
82041   Dali::Toolkit::DirectionBias arg4 ;
82042
82043   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82044   arg2 = (unsigned int)jarg2;
82045   arg3 = (float)jarg3;
82046   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
82047   {
82048     try {
82049       (arg1)->ScrollTo(arg2,arg3,arg4);
82050     } catch (std::out_of_range& e) {
82051       {
82052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82053       };
82054     } catch (std::exception& e) {
82055       {
82056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82057       };
82058     } catch (Dali::DaliException e) {
82059       {
82060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82061       };
82062     } catch (...) {
82063       {
82064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82065       };
82066     }
82067   }
82068
82069 }
82070
82071
82072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
82073   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82074   Dali::Actor *arg2 = 0 ;
82075
82076   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82077   arg2 = (Dali::Actor *)jarg2;
82078   if (!arg2) {
82079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82080     return ;
82081   }
82082   {
82083     try {
82084       (arg1)->ScrollTo(*arg2);
82085     } catch (std::out_of_range& e) {
82086       {
82087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82088       };
82089     } catch (std::exception& e) {
82090       {
82091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82092       };
82093     } catch (Dali::DaliException e) {
82094       {
82095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82096       };
82097     } catch (...) {
82098       {
82099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82100       };
82101     }
82102   }
82103
82104 }
82105
82106
82107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
82108   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82109   Dali::Actor *arg2 = 0 ;
82110   float arg3 ;
82111
82112   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82113   arg2 = (Dali::Actor *)jarg2;
82114   if (!arg2) {
82115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82116     return ;
82117   }
82118   arg3 = (float)jarg3;
82119   {
82120     try {
82121       (arg1)->ScrollTo(*arg2,arg3);
82122     } catch (std::out_of_range& e) {
82123       {
82124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82125       };
82126     } catch (std::exception& e) {
82127       {
82128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82129       };
82130     } catch (Dali::DaliException e) {
82131       {
82132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82133       };
82134     } catch (...) {
82135       {
82136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82137       };
82138     }
82139   }
82140
82141 }
82142
82143
82144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82145   unsigned int jresult ;
82146   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82147   bool result;
82148
82149   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82150   {
82151     try {
82152       result = (bool)(arg1)->ScrollToSnapPoint();
82153     } catch (std::out_of_range& e) {
82154       {
82155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82156       };
82157     } catch (std::exception& e) {
82158       {
82159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82160       };
82161     } catch (Dali::DaliException e) {
82162       {
82163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82164       };
82165     } catch (...) {
82166       {
82167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82168       };
82169     }
82170   }
82171
82172   jresult = result;
82173   return jresult;
82174 }
82175
82176
82177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82178   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82179   Dali::Constraint arg2 ;
82180   Dali::Constraint *argp2 ;
82181
82182   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82183   argp2 = (Dali::Constraint *)jarg2;
82184   if (!argp2) {
82185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82186     return ;
82187   }
82188   arg2 = *argp2;
82189   {
82190     try {
82191       (arg1)->ApplyConstraintToChildren(arg2);
82192     } catch (std::out_of_range& e) {
82193       {
82194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82195       };
82196     } catch (std::exception& e) {
82197       {
82198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82199       };
82200     } catch (Dali::DaliException e) {
82201       {
82202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82203       };
82204     } catch (...) {
82205       {
82206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82207       };
82208     }
82209   }
82210
82211 }
82212
82213
82214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82215   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82216
82217   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82218   {
82219     try {
82220       (arg1)->RemoveConstraintsFromChildren();
82221     } catch (std::out_of_range& e) {
82222       {
82223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82224       };
82225     } catch (std::exception& e) {
82226       {
82227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82228       };
82229     } catch (Dali::DaliException e) {
82230       {
82231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82232       };
82233     } catch (...) {
82234       {
82235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82236       };
82237     }
82238   }
82239
82240 }
82241
82242
82243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82244   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82245   Dali::Toolkit::ScrollViewEffect arg2 ;
82246   Dali::Toolkit::ScrollViewEffect *argp2 ;
82247
82248   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82249   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82250   if (!argp2) {
82251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82252     return ;
82253   }
82254   arg2 = *argp2;
82255   {
82256     try {
82257       (arg1)->ApplyEffect(arg2);
82258     } catch (std::out_of_range& e) {
82259       {
82260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82261       };
82262     } catch (std::exception& e) {
82263       {
82264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82265       };
82266     } catch (Dali::DaliException e) {
82267       {
82268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82269       };
82270     } catch (...) {
82271       {
82272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82273       };
82274     }
82275   }
82276
82277 }
82278
82279
82280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
82281   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82282   Dali::Toolkit::ScrollViewEffect arg2 ;
82283   Dali::Toolkit::ScrollViewEffect *argp2 ;
82284
82285   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82286   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82287   if (!argp2) {
82288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82289     return ;
82290   }
82291   arg2 = *argp2;
82292   {
82293     try {
82294       (arg1)->RemoveEffect(arg2);
82295     } catch (std::out_of_range& e) {
82296       {
82297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82298       };
82299     } catch (std::exception& e) {
82300       {
82301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82302       };
82303     } catch (Dali::DaliException e) {
82304       {
82305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82306       };
82307     } catch (...) {
82308       {
82309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82310       };
82311     }
82312   }
82313
82314 }
82315
82316
82317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82318   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82319
82320   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82321   {
82322     try {
82323       (arg1)->RemoveAllEffects();
82324     } catch (std::out_of_range& e) {
82325       {
82326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82327       };
82328     } catch (std::exception& e) {
82329       {
82330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82331       };
82332     } catch (Dali::DaliException e) {
82333       {
82334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82335       };
82336     } catch (...) {
82337       {
82338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82339       };
82340     }
82341   }
82342
82343 }
82344
82345
82346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82347   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82348   Dali::Actor arg2 ;
82349   Dali::Actor *argp2 ;
82350
82351   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82352   argp2 = (Dali::Actor *)jarg2;
82353   if (!argp2) {
82354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82355     return ;
82356   }
82357   arg2 = *argp2;
82358   {
82359     try {
82360       (arg1)->BindActor(arg2);
82361     } catch (std::out_of_range& e) {
82362       {
82363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82364       };
82365     } catch (std::exception& e) {
82366       {
82367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82368       };
82369     } catch (Dali::DaliException e) {
82370       {
82371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82372       };
82373     } catch (...) {
82374       {
82375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82376       };
82377     }
82378   }
82379
82380 }
82381
82382
82383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82384   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82385   Dali::Actor arg2 ;
82386   Dali::Actor *argp2 ;
82387
82388   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82389   argp2 = (Dali::Actor *)jarg2;
82390   if (!argp2) {
82391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82392     return ;
82393   }
82394   arg2 = *argp2;
82395   {
82396     try {
82397       (arg1)->UnbindActor(arg2);
82398     } catch (std::out_of_range& e) {
82399       {
82400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82401       };
82402     } catch (std::exception& e) {
82403       {
82404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82405       };
82406     } catch (Dali::DaliException e) {
82407       {
82408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82409       };
82410     } catch (...) {
82411       {
82412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82413       };
82414     }
82415   }
82416
82417 }
82418
82419
82420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82421   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82422   Dali::Radian arg2 ;
82423   Dali::Radian arg3 ;
82424   Dali::Radian *argp2 ;
82425   Dali::Radian *argp3 ;
82426
82427   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82428   argp2 = (Dali::Radian *)jarg2;
82429   if (!argp2) {
82430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82431     return ;
82432   }
82433   arg2 = *argp2;
82434   argp3 = (Dali::Radian *)jarg3;
82435   if (!argp3) {
82436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82437     return ;
82438   }
82439   arg3 = *argp3;
82440   {
82441     try {
82442       (arg1)->SetScrollingDirection(arg2,arg3);
82443     } catch (std::out_of_range& e) {
82444       {
82445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82446       };
82447     } catch (std::exception& e) {
82448       {
82449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82450       };
82451     } catch (Dali::DaliException e) {
82452       {
82453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82454       };
82455     } catch (...) {
82456       {
82457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82458       };
82459     }
82460   }
82461
82462 }
82463
82464
82465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82466   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82467   Dali::Radian arg2 ;
82468   Dali::Radian *argp2 ;
82469
82470   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82471   argp2 = (Dali::Radian *)jarg2;
82472   if (!argp2) {
82473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82474     return ;
82475   }
82476   arg2 = *argp2;
82477   {
82478     try {
82479       (arg1)->SetScrollingDirection(arg2);
82480     } catch (std::out_of_range& e) {
82481       {
82482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82483       };
82484     } catch (std::exception& e) {
82485       {
82486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82487       };
82488     } catch (Dali::DaliException e) {
82489       {
82490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82491       };
82492     } catch (...) {
82493       {
82494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82495       };
82496     }
82497   }
82498
82499 }
82500
82501
82502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82503   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82504   Dali::Radian arg2 ;
82505   Dali::Radian *argp2 ;
82506
82507   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82508   argp2 = (Dali::Radian *)jarg2;
82509   if (!argp2) {
82510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82511     return ;
82512   }
82513   arg2 = *argp2;
82514   {
82515     try {
82516       (arg1)->RemoveScrollingDirection(arg2);
82517     } catch (std::out_of_range& e) {
82518       {
82519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82520       };
82521     } catch (std::exception& e) {
82522       {
82523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82524       };
82525     } catch (Dali::DaliException e) {
82526       {
82527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82528       };
82529     } catch (...) {
82530       {
82531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82532       };
82533     }
82534   }
82535
82536 }
82537
82538
82539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82540   void * jresult ;
82541   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82542   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82543
82544   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82545   {
82546     try {
82547       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82548     } catch (std::out_of_range& e) {
82549       {
82550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82551       };
82552     } catch (std::exception& e) {
82553       {
82554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82555       };
82556     } catch (Dali::DaliException e) {
82557       {
82558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82559       };
82560     } catch (...) {
82561       {
82562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82563       };
82564     }
82565   }
82566
82567   jresult = (void *)result;
82568   return jresult;
82569 }
82570
82571
82572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82573   int jresult ;
82574   int result;
82575
82576   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82577   jresult = (int)result;
82578   return jresult;
82579 }
82580
82581
82582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82583   int jresult ;
82584   int result;
82585
82586   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82587   jresult = (int)result;
82588   return jresult;
82589 }
82590
82591
82592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82593   int jresult ;
82594   int result;
82595
82596   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82597   jresult = (int)result;
82598   return jresult;
82599 }
82600
82601
82602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82603   int jresult ;
82604   int result;
82605
82606   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82607   jresult = (int)result;
82608   return jresult;
82609 }
82610
82611
82612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82613   int jresult ;
82614   int result;
82615
82616   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82617   jresult = (int)result;
82618   return jresult;
82619 }
82620
82621
82622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82623   void * jresult ;
82624   Dali::Toolkit::TableView::Property *result = 0 ;
82625
82626   {
82627     try {
82628       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82629     } catch (std::out_of_range& e) {
82630       {
82631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82632       };
82633     } catch (std::exception& e) {
82634       {
82635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82636       };
82637     } catch (Dali::DaliException e) {
82638       {
82639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82640       };
82641     } catch (...) {
82642       {
82643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82644       };
82645     }
82646   }
82647
82648   jresult = (void *)result;
82649   return jresult;
82650 }
82651
82652
82653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82654   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82655
82656   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82657   {
82658     try {
82659       delete arg1;
82660     } catch (std::out_of_range& e) {
82661       {
82662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82663       };
82664     } catch (std::exception& e) {
82665       {
82666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82667       };
82668     } catch (Dali::DaliException e) {
82669       {
82670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82671       };
82672     } catch (...) {
82673       {
82674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82675       };
82676     }
82677   }
82678
82679 }
82680
82681
82682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82683   int jresult ;
82684   int result;
82685
82686   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82687   jresult = (int)result;
82688   return jresult;
82689 }
82690
82691
82692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82693   int jresult ;
82694   int result;
82695
82696   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82697   jresult = (int)result;
82698   return jresult;
82699 }
82700
82701
82702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82703   int jresult ;
82704   int result;
82705
82706   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82707   jresult = (int)result;
82708   return jresult;
82709 }
82710
82711
82712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82713   int jresult ;
82714   int result;
82715
82716   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82717   jresult = (int)result;
82718   return jresult;
82719 }
82720
82721
82722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82723   int jresult ;
82724   int result;
82725
82726   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82727   jresult = (int)result;
82728   return jresult;
82729 }
82730
82731
82732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82733   void * jresult ;
82734   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82735
82736   {
82737     try {
82738       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82739     } catch (std::out_of_range& e) {
82740       {
82741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82742       };
82743     } catch (std::exception& e) {
82744       {
82745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82746       };
82747     } catch (Dali::DaliException e) {
82748       {
82749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82750       };
82751     } catch (...) {
82752       {
82753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82754       };
82755     }
82756   }
82757
82758   jresult = (void *)result;
82759   return jresult;
82760 }
82761
82762
82763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82764   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82765
82766   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82767   {
82768     try {
82769       delete arg1;
82770     } catch (std::out_of_range& e) {
82771       {
82772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82773       };
82774     } catch (std::exception& e) {
82775       {
82776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82777       };
82778     } catch (Dali::DaliException e) {
82779       {
82780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82781       };
82782     } catch (...) {
82783       {
82784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82785       };
82786     }
82787   }
82788
82789 }
82790
82791
82792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82793   void * jresult ;
82794   unsigned int arg1 ;
82795   unsigned int arg2 ;
82796   unsigned int arg3 ;
82797   unsigned int arg4 ;
82798   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82799
82800   arg1 = (unsigned int)jarg1;
82801   arg2 = (unsigned int)jarg2;
82802   arg3 = (unsigned int)jarg3;
82803   arg4 = (unsigned int)jarg4;
82804   {
82805     try {
82806       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82807     } catch (std::out_of_range& e) {
82808       {
82809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82810       };
82811     } catch (std::exception& e) {
82812       {
82813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82814       };
82815     } catch (Dali::DaliException e) {
82816       {
82817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82818       };
82819     } catch (...) {
82820       {
82821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82822       };
82823     }
82824   }
82825
82826   jresult = (void *)result;
82827   return jresult;
82828 }
82829
82830
82831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82832   void * jresult ;
82833   unsigned int arg1 ;
82834   unsigned int arg2 ;
82835   unsigned int arg3 ;
82836   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82837
82838   arg1 = (unsigned int)jarg1;
82839   arg2 = (unsigned int)jarg2;
82840   arg3 = (unsigned int)jarg3;
82841   {
82842     try {
82843       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82844     } catch (std::out_of_range& e) {
82845       {
82846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82847       };
82848     } catch (std::exception& e) {
82849       {
82850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82851       };
82852     } catch (Dali::DaliException e) {
82853       {
82854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82855       };
82856     } catch (...) {
82857       {
82858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82859       };
82860     }
82861   }
82862
82863   jresult = (void *)result;
82864   return jresult;
82865 }
82866
82867
82868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82869   void * jresult ;
82870   unsigned int arg1 ;
82871   unsigned int arg2 ;
82872   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82873
82874   arg1 = (unsigned int)jarg1;
82875   arg2 = (unsigned int)jarg2;
82876   {
82877     try {
82878       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82879     } catch (std::out_of_range& e) {
82880       {
82881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82882       };
82883     } catch (std::exception& e) {
82884       {
82885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82886       };
82887     } catch (Dali::DaliException e) {
82888       {
82889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82890       };
82891     } catch (...) {
82892       {
82893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82894       };
82895     }
82896   }
82897
82898   jresult = (void *)result;
82899   return jresult;
82900 }
82901
82902
82903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82904   void * jresult ;
82905   unsigned int arg1 ;
82906   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82907
82908   arg1 = (unsigned int)jarg1;
82909   {
82910     try {
82911       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82912     } catch (std::out_of_range& e) {
82913       {
82914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82915       };
82916     } catch (std::exception& e) {
82917       {
82918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82919       };
82920     } catch (Dali::DaliException e) {
82921       {
82922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82923       };
82924     } catch (...) {
82925       {
82926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82927       };
82928     }
82929   }
82930
82931   jresult = (void *)result;
82932   return jresult;
82933 }
82934
82935
82936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82937   void * jresult ;
82938   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82939
82940   {
82941     try {
82942       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82943     } catch (std::out_of_range& e) {
82944       {
82945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82946       };
82947     } catch (std::exception& e) {
82948       {
82949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82950       };
82951     } catch (Dali::DaliException e) {
82952       {
82953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82954       };
82955     } catch (...) {
82956       {
82957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82958       };
82959     }
82960   }
82961
82962   jresult = (void *)result;
82963   return jresult;
82964 }
82965
82966
82967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82968   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82969   unsigned int arg2 ;
82970
82971   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82972   arg2 = (unsigned int)jarg2;
82973   if (arg1) (arg1)->rowIndex = arg2;
82974 }
82975
82976
82977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82978   unsigned int jresult ;
82979   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82980   unsigned int result;
82981
82982   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82983   result = (unsigned int) ((arg1)->rowIndex);
82984   jresult = result;
82985   return jresult;
82986 }
82987
82988
82989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82990   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82991   unsigned int arg2 ;
82992
82993   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82994   arg2 = (unsigned int)jarg2;
82995   if (arg1) (arg1)->columnIndex = arg2;
82996 }
82997
82998
82999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
83000   unsigned int jresult ;
83001   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83002   unsigned int result;
83003
83004   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83005   result = (unsigned int) ((arg1)->columnIndex);
83006   jresult = result;
83007   return jresult;
83008 }
83009
83010
83011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
83012   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83013   unsigned int arg2 ;
83014
83015   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83016   arg2 = (unsigned int)jarg2;
83017   if (arg1) (arg1)->rowSpan = arg2;
83018 }
83019
83020
83021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
83022   unsigned int jresult ;
83023   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83024   unsigned int result;
83025
83026   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83027   result = (unsigned int) ((arg1)->rowSpan);
83028   jresult = result;
83029   return jresult;
83030 }
83031
83032
83033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
83034   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83035   unsigned int arg2 ;
83036
83037   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83038   arg2 = (unsigned int)jarg2;
83039   if (arg1) (arg1)->columnSpan = arg2;
83040 }
83041
83042
83043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
83044   unsigned int jresult ;
83045   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83046   unsigned int result;
83047
83048   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83049   result = (unsigned int) ((arg1)->columnSpan);
83050   jresult = result;
83051   return jresult;
83052 }
83053
83054
83055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
83056   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83057
83058   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83059   {
83060     try {
83061       delete arg1;
83062     } catch (std::out_of_range& e) {
83063       {
83064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83065       };
83066     } catch (std::exception& e) {
83067       {
83068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83069       };
83070     } catch (Dali::DaliException e) {
83071       {
83072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83073       };
83074     } catch (...) {
83075       {
83076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83077       };
83078     }
83079   }
83080
83081 }
83082
83083
83084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
83085   void * jresult ;
83086   Dali::Toolkit::TableView *result = 0 ;
83087
83088   {
83089     try {
83090       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
83091     } catch (std::out_of_range& e) {
83092       {
83093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83094       };
83095     } catch (std::exception& e) {
83096       {
83097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83098       };
83099     } catch (Dali::DaliException e) {
83100       {
83101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83102       };
83103     } catch (...) {
83104       {
83105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83106       };
83107     }
83108   }
83109
83110   jresult = (void *)result;
83111   return jresult;
83112 }
83113
83114
83115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
83116   void * jresult ;
83117   Dali::Toolkit::TableView *arg1 = 0 ;
83118   Dali::Toolkit::TableView *result = 0 ;
83119
83120   arg1 = (Dali::Toolkit::TableView *)jarg1;
83121   if (!arg1) {
83122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83123     return 0;
83124   }
83125   {
83126     try {
83127       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
83128     } catch (std::out_of_range& e) {
83129       {
83130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83131       };
83132     } catch (std::exception& e) {
83133       {
83134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83135       };
83136     } catch (Dali::DaliException e) {
83137       {
83138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83139       };
83140     } catch (...) {
83141       {
83142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83143       };
83144     }
83145   }
83146
83147   jresult = (void *)result;
83148   return jresult;
83149 }
83150
83151
83152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
83153   void * jresult ;
83154   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83155   Dali::Toolkit::TableView *arg2 = 0 ;
83156   Dali::Toolkit::TableView *result = 0 ;
83157
83158   arg1 = (Dali::Toolkit::TableView *)jarg1;
83159   arg2 = (Dali::Toolkit::TableView *)jarg2;
83160   if (!arg2) {
83161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83162     return 0;
83163   }
83164   {
83165     try {
83166       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
83167     } catch (std::out_of_range& e) {
83168       {
83169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83170       };
83171     } catch (std::exception& e) {
83172       {
83173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83174       };
83175     } catch (Dali::DaliException e) {
83176       {
83177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83178       };
83179     } catch (...) {
83180       {
83181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83182       };
83183     }
83184   }
83185
83186   jresult = (void *)result;
83187   return jresult;
83188 }
83189
83190
83191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83192   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83193
83194   arg1 = (Dali::Toolkit::TableView *)jarg1;
83195   {
83196     try {
83197       delete arg1;
83198     } catch (std::out_of_range& e) {
83199       {
83200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83201       };
83202     } catch (std::exception& e) {
83203       {
83204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83205       };
83206     } catch (Dali::DaliException e) {
83207       {
83208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83209       };
83210     } catch (...) {
83211       {
83212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83213       };
83214     }
83215   }
83216
83217 }
83218
83219
83220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83221   void * jresult ;
83222   unsigned int arg1 ;
83223   unsigned int arg2 ;
83224   Dali::Toolkit::TableView result;
83225
83226   arg1 = (unsigned int)jarg1;
83227   arg2 = (unsigned int)jarg2;
83228   {
83229     try {
83230       result = Dali::Toolkit::TableView::New(arg1,arg2);
83231     } catch (std::out_of_range& e) {
83232       {
83233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83234       };
83235     } catch (std::exception& e) {
83236       {
83237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83238       };
83239     } catch (Dali::DaliException e) {
83240       {
83241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83242       };
83243     } catch (...) {
83244       {
83245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83246       };
83247     }
83248   }
83249
83250   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83251   return jresult;
83252 }
83253
83254
83255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83256   void * jresult ;
83257   Dali::BaseHandle arg1 ;
83258   Dali::BaseHandle *argp1 ;
83259   Dali::Toolkit::TableView result;
83260
83261   argp1 = (Dali::BaseHandle *)jarg1;
83262   if (!argp1) {
83263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83264     return 0;
83265   }
83266   arg1 = *argp1;
83267   {
83268     try {
83269       result = Dali::Toolkit::TableView::DownCast(arg1);
83270     } catch (std::out_of_range& e) {
83271       {
83272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83273       };
83274     } catch (std::exception& e) {
83275       {
83276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83277       };
83278     } catch (Dali::DaliException e) {
83279       {
83280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83281       };
83282     } catch (...) {
83283       {
83284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83285       };
83286     }
83287   }
83288
83289   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83290   return jresult;
83291 }
83292
83293
83294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83295   unsigned int jresult ;
83296   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83297   Dali::Actor arg2 ;
83298   Dali::Toolkit::TableView::CellPosition arg3 ;
83299   Dali::Actor *argp2 ;
83300   Dali::Toolkit::TableView::CellPosition *argp3 ;
83301   bool result;
83302
83303   arg1 = (Dali::Toolkit::TableView *)jarg1;
83304   argp2 = (Dali::Actor *)jarg2;
83305   if (!argp2) {
83306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83307     return 0;
83308   }
83309   arg2 = *argp2;
83310   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83311   if (!argp3) {
83312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83313     return 0;
83314   }
83315   arg3 = *argp3;
83316   {
83317     try {
83318       result = (bool)(arg1)->AddChild(arg2,arg3);
83319     } catch (std::out_of_range& e) {
83320       {
83321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83322       };
83323     } catch (std::exception& e) {
83324       {
83325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83326       };
83327     } catch (Dali::DaliException e) {
83328       {
83329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83330       };
83331     } catch (...) {
83332       {
83333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83334       };
83335     }
83336   }
83337
83338   jresult = result;
83339   return jresult;
83340 }
83341
83342
83343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83344   void * jresult ;
83345   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83346   Dali::Toolkit::TableView::CellPosition arg2 ;
83347   Dali::Toolkit::TableView::CellPosition *argp2 ;
83348   Dali::Actor result;
83349
83350   arg1 = (Dali::Toolkit::TableView *)jarg1;
83351   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83352   if (!argp2) {
83353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83354     return 0;
83355   }
83356   arg2 = *argp2;
83357   {
83358     try {
83359       result = (arg1)->GetChildAt(arg2);
83360     } catch (std::out_of_range& e) {
83361       {
83362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83363       };
83364     } catch (std::exception& e) {
83365       {
83366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83367       };
83368     } catch (Dali::DaliException e) {
83369       {
83370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83371       };
83372     } catch (...) {
83373       {
83374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83375       };
83376     }
83377   }
83378
83379   jresult = new Dali::Actor((const Dali::Actor &)result);
83380   return jresult;
83381 }
83382
83383
83384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83385   void * jresult ;
83386   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83387   Dali::Toolkit::TableView::CellPosition arg2 ;
83388   Dali::Toolkit::TableView::CellPosition *argp2 ;
83389   Dali::Actor result;
83390
83391   arg1 = (Dali::Toolkit::TableView *)jarg1;
83392   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83393   if (!argp2) {
83394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83395     return 0;
83396   }
83397   arg2 = *argp2;
83398   {
83399     try {
83400       result = (arg1)->RemoveChildAt(arg2);
83401     } catch (std::out_of_range& e) {
83402       {
83403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83404       };
83405     } catch (std::exception& e) {
83406       {
83407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83408       };
83409     } catch (Dali::DaliException e) {
83410       {
83411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83412       };
83413     } catch (...) {
83414       {
83415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83416       };
83417     }
83418   }
83419
83420   jresult = new Dali::Actor((const Dali::Actor &)result);
83421   return jresult;
83422 }
83423
83424
83425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83426   unsigned int jresult ;
83427   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83428   Dali::Actor arg2 ;
83429   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83430   Dali::Actor *argp2 ;
83431   bool result;
83432
83433   arg1 = (Dali::Toolkit::TableView *)jarg1;
83434   argp2 = (Dali::Actor *)jarg2;
83435   if (!argp2) {
83436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83437     return 0;
83438   }
83439   arg2 = *argp2;
83440   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83441   if (!arg3) {
83442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83443     return 0;
83444   }
83445   {
83446     try {
83447       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83448     } catch (std::out_of_range& e) {
83449       {
83450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83451       };
83452     } catch (std::exception& e) {
83453       {
83454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83455       };
83456     } catch (Dali::DaliException e) {
83457       {
83458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83459       };
83460     } catch (...) {
83461       {
83462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83463       };
83464     }
83465   }
83466
83467   jresult = result;
83468   return jresult;
83469 }
83470
83471
83472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83473   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83474   unsigned int arg2 ;
83475
83476   arg1 = (Dali::Toolkit::TableView *)jarg1;
83477   arg2 = (unsigned int)jarg2;
83478   {
83479     try {
83480       (arg1)->InsertRow(arg2);
83481     } catch (std::out_of_range& e) {
83482       {
83483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83484       };
83485     } catch (std::exception& e) {
83486       {
83487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83488       };
83489     } catch (Dali::DaliException e) {
83490       {
83491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83492       };
83493     } catch (...) {
83494       {
83495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83496       };
83497     }
83498   }
83499
83500 }
83501
83502
83503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83504   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83505   unsigned int arg2 ;
83506
83507   arg1 = (Dali::Toolkit::TableView *)jarg1;
83508   arg2 = (unsigned int)jarg2;
83509   {
83510     try {
83511       (arg1)->DeleteRow(arg2);
83512     } catch (std::out_of_range& e) {
83513       {
83514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83515       };
83516     } catch (std::exception& e) {
83517       {
83518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83519       };
83520     } catch (Dali::DaliException e) {
83521       {
83522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83523       };
83524     } catch (...) {
83525       {
83526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83527       };
83528     }
83529   }
83530
83531 }
83532
83533
83534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83535   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83536   unsigned int arg2 ;
83537   std::vector< Dali::Actor > *arg3 = 0 ;
83538
83539   arg1 = (Dali::Toolkit::TableView *)jarg1;
83540   arg2 = (unsigned int)jarg2;
83541   arg3 = (std::vector< Dali::Actor > *)jarg3;
83542   if (!arg3) {
83543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83544     return ;
83545   }
83546   {
83547     try {
83548       (arg1)->DeleteRow(arg2,*arg3);
83549     } catch (std::out_of_range& e) {
83550       {
83551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83552       };
83553     } catch (std::exception& e) {
83554       {
83555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83556       };
83557     } catch (Dali::DaliException e) {
83558       {
83559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83560       };
83561     } catch (...) {
83562       {
83563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83564       };
83565     }
83566   }
83567
83568 }
83569
83570
83571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83572   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83573   unsigned int arg2 ;
83574
83575   arg1 = (Dali::Toolkit::TableView *)jarg1;
83576   arg2 = (unsigned int)jarg2;
83577   {
83578     try {
83579       (arg1)->InsertColumn(arg2);
83580     } catch (std::out_of_range& e) {
83581       {
83582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83583       };
83584     } catch (std::exception& e) {
83585       {
83586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83587       };
83588     } catch (Dali::DaliException e) {
83589       {
83590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83591       };
83592     } catch (...) {
83593       {
83594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83595       };
83596     }
83597   }
83598
83599 }
83600
83601
83602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83603   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83604   unsigned int arg2 ;
83605
83606   arg1 = (Dali::Toolkit::TableView *)jarg1;
83607   arg2 = (unsigned int)jarg2;
83608   {
83609     try {
83610       (arg1)->DeleteColumn(arg2);
83611     } catch (std::out_of_range& e) {
83612       {
83613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83614       };
83615     } catch (std::exception& e) {
83616       {
83617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83618       };
83619     } catch (Dali::DaliException e) {
83620       {
83621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83622       };
83623     } catch (...) {
83624       {
83625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83626       };
83627     }
83628   }
83629
83630 }
83631
83632
83633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83634   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83635   unsigned int arg2 ;
83636   std::vector< Dali::Actor > *arg3 = 0 ;
83637
83638   arg1 = (Dali::Toolkit::TableView *)jarg1;
83639   arg2 = (unsigned int)jarg2;
83640   arg3 = (std::vector< Dali::Actor > *)jarg3;
83641   if (!arg3) {
83642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83643     return ;
83644   }
83645   {
83646     try {
83647       (arg1)->DeleteColumn(arg2,*arg3);
83648     } catch (std::out_of_range& e) {
83649       {
83650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83651       };
83652     } catch (std::exception& e) {
83653       {
83654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83655       };
83656     } catch (Dali::DaliException e) {
83657       {
83658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83659       };
83660     } catch (...) {
83661       {
83662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83663       };
83664     }
83665   }
83666
83667 }
83668
83669
83670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83671   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83672   unsigned int arg2 ;
83673   unsigned int arg3 ;
83674
83675   arg1 = (Dali::Toolkit::TableView *)jarg1;
83676   arg2 = (unsigned int)jarg2;
83677   arg3 = (unsigned int)jarg3;
83678   {
83679     try {
83680       (arg1)->Resize(arg2,arg3);
83681     } catch (std::out_of_range& e) {
83682       {
83683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83684       };
83685     } catch (std::exception& e) {
83686       {
83687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83688       };
83689     } catch (Dali::DaliException e) {
83690       {
83691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83692       };
83693     } catch (...) {
83694       {
83695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83696       };
83697     }
83698   }
83699
83700 }
83701
83702
83703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83704   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83705   unsigned int arg2 ;
83706   unsigned int arg3 ;
83707   std::vector< Dali::Actor > *arg4 = 0 ;
83708
83709   arg1 = (Dali::Toolkit::TableView *)jarg1;
83710   arg2 = (unsigned int)jarg2;
83711   arg3 = (unsigned int)jarg3;
83712   arg4 = (std::vector< Dali::Actor > *)jarg4;
83713   if (!arg4) {
83714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83715     return ;
83716   }
83717   {
83718     try {
83719       (arg1)->Resize(arg2,arg3,*arg4);
83720     } catch (std::out_of_range& e) {
83721       {
83722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83723       };
83724     } catch (std::exception& e) {
83725       {
83726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83727       };
83728     } catch (Dali::DaliException e) {
83729       {
83730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83731       };
83732     } catch (...) {
83733       {
83734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83735       };
83736     }
83737   }
83738
83739 }
83740
83741
83742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83743   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83744   Dali::Size arg2 ;
83745   Dali::Size *argp2 ;
83746
83747   arg1 = (Dali::Toolkit::TableView *)jarg1;
83748   argp2 = (Dali::Size *)jarg2;
83749   if (!argp2) {
83750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83751     return ;
83752   }
83753   arg2 = *argp2;
83754   {
83755     try {
83756       (arg1)->SetCellPadding(arg2);
83757     } catch (std::out_of_range& e) {
83758       {
83759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83760       };
83761     } catch (std::exception& e) {
83762       {
83763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83764       };
83765     } catch (Dali::DaliException e) {
83766       {
83767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83768       };
83769     } catch (...) {
83770       {
83771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83772       };
83773     }
83774   }
83775
83776 }
83777
83778
83779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83780   void * jresult ;
83781   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83782   Dali::Size result;
83783
83784   arg1 = (Dali::Toolkit::TableView *)jarg1;
83785   {
83786     try {
83787       result = (arg1)->GetCellPadding();
83788     } catch (std::out_of_range& e) {
83789       {
83790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83791       };
83792     } catch (std::exception& e) {
83793       {
83794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83795       };
83796     } catch (Dali::DaliException e) {
83797       {
83798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83799       };
83800     } catch (...) {
83801       {
83802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83803       };
83804     }
83805   }
83806
83807   jresult = new Dali::Size((const Dali::Size &)result);
83808   return jresult;
83809 }
83810
83811
83812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83813   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83814   unsigned int arg2 ;
83815
83816   arg1 = (Dali::Toolkit::TableView *)jarg1;
83817   arg2 = (unsigned int)jarg2;
83818   {
83819     try {
83820       (arg1)->SetFitHeight(arg2);
83821     } catch (std::out_of_range& e) {
83822       {
83823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83824       };
83825     } catch (std::exception& e) {
83826       {
83827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83828       };
83829     } catch (Dali::DaliException e) {
83830       {
83831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83832       };
83833     } catch (...) {
83834       {
83835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83836       };
83837     }
83838   }
83839
83840 }
83841
83842
83843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83844   unsigned int jresult ;
83845   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83846   unsigned int arg2 ;
83847   bool result;
83848
83849   arg1 = (Dali::Toolkit::TableView *)jarg1;
83850   arg2 = (unsigned int)jarg2;
83851   {
83852     try {
83853       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83854     } catch (std::out_of_range& e) {
83855       {
83856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83857       };
83858     } catch (std::exception& e) {
83859       {
83860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83861       };
83862     } catch (Dali::DaliException e) {
83863       {
83864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83865       };
83866     } catch (...) {
83867       {
83868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83869       };
83870     }
83871   }
83872
83873   jresult = result;
83874   return jresult;
83875 }
83876
83877
83878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83879   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83880   unsigned int arg2 ;
83881
83882   arg1 = (Dali::Toolkit::TableView *)jarg1;
83883   arg2 = (unsigned int)jarg2;
83884   {
83885     try {
83886       (arg1)->SetFitWidth(arg2);
83887     } catch (std::out_of_range& e) {
83888       {
83889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83890       };
83891     } catch (std::exception& e) {
83892       {
83893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83894       };
83895     } catch (Dali::DaliException e) {
83896       {
83897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83898       };
83899     } catch (...) {
83900       {
83901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83902       };
83903     }
83904   }
83905
83906 }
83907
83908
83909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83910   unsigned int jresult ;
83911   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83912   unsigned int arg2 ;
83913   bool result;
83914
83915   arg1 = (Dali::Toolkit::TableView *)jarg1;
83916   arg2 = (unsigned int)jarg2;
83917   {
83918     try {
83919       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83920     } catch (std::out_of_range& e) {
83921       {
83922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83923       };
83924     } catch (std::exception& e) {
83925       {
83926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83927       };
83928     } catch (Dali::DaliException e) {
83929       {
83930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83931       };
83932     } catch (...) {
83933       {
83934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83935       };
83936     }
83937   }
83938
83939   jresult = result;
83940   return jresult;
83941 }
83942
83943
83944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83945   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83946   unsigned int arg2 ;
83947   float arg3 ;
83948
83949   arg1 = (Dali::Toolkit::TableView *)jarg1;
83950   arg2 = (unsigned int)jarg2;
83951   arg3 = (float)jarg3;
83952   {
83953     try {
83954       (arg1)->SetFixedHeight(arg2,arg3);
83955     } catch (std::out_of_range& e) {
83956       {
83957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83958       };
83959     } catch (std::exception& e) {
83960       {
83961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83962       };
83963     } catch (Dali::DaliException e) {
83964       {
83965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83966       };
83967     } catch (...) {
83968       {
83969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83970       };
83971     }
83972   }
83973
83974 }
83975
83976
83977 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83978   float jresult ;
83979   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83980   unsigned int arg2 ;
83981   float result;
83982
83983   arg1 = (Dali::Toolkit::TableView *)jarg1;
83984   arg2 = (unsigned int)jarg2;
83985   {
83986     try {
83987       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83988     } catch (std::out_of_range& e) {
83989       {
83990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83991       };
83992     } catch (std::exception& e) {
83993       {
83994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83995       };
83996     } catch (Dali::DaliException e) {
83997       {
83998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83999       };
84000     } catch (...) {
84001       {
84002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84003       };
84004     }
84005   }
84006
84007   jresult = result;
84008   return jresult;
84009 }
84010
84011
84012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
84013   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84014   unsigned int arg2 ;
84015   float arg3 ;
84016
84017   arg1 = (Dali::Toolkit::TableView *)jarg1;
84018   arg2 = (unsigned int)jarg2;
84019   arg3 = (float)jarg3;
84020   {
84021     try {
84022       (arg1)->SetRelativeHeight(arg2,arg3);
84023     } catch (std::out_of_range& e) {
84024       {
84025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84026       };
84027     } catch (std::exception& e) {
84028       {
84029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84030       };
84031     } catch (Dali::DaliException e) {
84032       {
84033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84034       };
84035     } catch (...) {
84036       {
84037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84038       };
84039     }
84040   }
84041
84042 }
84043
84044
84045 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
84046   float jresult ;
84047   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84048   unsigned int arg2 ;
84049   float result;
84050
84051   arg1 = (Dali::Toolkit::TableView *)jarg1;
84052   arg2 = (unsigned int)jarg2;
84053   {
84054     try {
84055       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
84056     } catch (std::out_of_range& e) {
84057       {
84058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84059       };
84060     } catch (std::exception& e) {
84061       {
84062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84063       };
84064     } catch (Dali::DaliException e) {
84065       {
84066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84067       };
84068     } catch (...) {
84069       {
84070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84071       };
84072     }
84073   }
84074
84075   jresult = result;
84076   return jresult;
84077 }
84078
84079
84080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84081   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84082   unsigned int arg2 ;
84083   float arg3 ;
84084
84085   arg1 = (Dali::Toolkit::TableView *)jarg1;
84086   arg2 = (unsigned int)jarg2;
84087   arg3 = (float)jarg3;
84088   {
84089     try {
84090       (arg1)->SetFixedWidth(arg2,arg3);
84091     } catch (std::out_of_range& e) {
84092       {
84093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84094       };
84095     } catch (std::exception& e) {
84096       {
84097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84098       };
84099     } catch (Dali::DaliException e) {
84100       {
84101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84102       };
84103     } catch (...) {
84104       {
84105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84106       };
84107     }
84108   }
84109
84110 }
84111
84112
84113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
84114   float jresult ;
84115   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84116   unsigned int arg2 ;
84117   float result;
84118
84119   arg1 = (Dali::Toolkit::TableView *)jarg1;
84120   arg2 = (unsigned int)jarg2;
84121   {
84122     try {
84123       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
84124     } catch (std::out_of_range& e) {
84125       {
84126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84127       };
84128     } catch (std::exception& e) {
84129       {
84130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84131       };
84132     } catch (Dali::DaliException e) {
84133       {
84134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84135       };
84136     } catch (...) {
84137       {
84138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84139       };
84140     }
84141   }
84142
84143   jresult = result;
84144   return jresult;
84145 }
84146
84147
84148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84149   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84150   unsigned int arg2 ;
84151   float arg3 ;
84152
84153   arg1 = (Dali::Toolkit::TableView *)jarg1;
84154   arg2 = (unsigned int)jarg2;
84155   arg3 = (float)jarg3;
84156   {
84157     try {
84158       (arg1)->SetRelativeWidth(arg2,arg3);
84159     } catch (std::out_of_range& e) {
84160       {
84161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84162       };
84163     } catch (std::exception& e) {
84164       {
84165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84166       };
84167     } catch (Dali::DaliException e) {
84168       {
84169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84170       };
84171     } catch (...) {
84172       {
84173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84174       };
84175     }
84176   }
84177
84178 }
84179
84180
84181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84182   float jresult ;
84183   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84184   unsigned int arg2 ;
84185   float result;
84186
84187   arg1 = (Dali::Toolkit::TableView *)jarg1;
84188   arg2 = (unsigned int)jarg2;
84189   {
84190     try {
84191       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84192     } catch (std::out_of_range& e) {
84193       {
84194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84195       };
84196     } catch (std::exception& e) {
84197       {
84198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84199       };
84200     } catch (Dali::DaliException e) {
84201       {
84202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84203       };
84204     } catch (...) {
84205       {
84206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84207       };
84208     }
84209   }
84210
84211   jresult = result;
84212   return jresult;
84213 }
84214
84215
84216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84217   unsigned int jresult ;
84218   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84219   unsigned int result;
84220
84221   arg1 = (Dali::Toolkit::TableView *)jarg1;
84222   {
84223     try {
84224       result = (unsigned int)(arg1)->GetRows();
84225     } catch (std::out_of_range& e) {
84226       {
84227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84228       };
84229     } catch (std::exception& e) {
84230       {
84231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84232       };
84233     } catch (Dali::DaliException e) {
84234       {
84235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84236       };
84237     } catch (...) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84240       };
84241     }
84242   }
84243
84244   jresult = result;
84245   return jresult;
84246 }
84247
84248
84249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84250   unsigned int jresult ;
84251   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84252   unsigned int result;
84253
84254   arg1 = (Dali::Toolkit::TableView *)jarg1;
84255   {
84256     try {
84257       result = (unsigned int)(arg1)->GetColumns();
84258     } catch (std::out_of_range& e) {
84259       {
84260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84261       };
84262     } catch (std::exception& e) {
84263       {
84264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84265       };
84266     } catch (Dali::DaliException e) {
84267       {
84268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84269       };
84270     } catch (...) {
84271       {
84272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84273       };
84274     }
84275   }
84276
84277   jresult = result;
84278   return jresult;
84279 }
84280
84281
84282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84283   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84284   Dali::Toolkit::TableView::CellPosition arg2 ;
84285   Dali::HorizontalAlignment::Type arg3 ;
84286   Dali::VerticalAlignment::Type arg4 ;
84287   Dali::Toolkit::TableView::CellPosition *argp2 ;
84288
84289   arg1 = (Dali::Toolkit::TableView *)jarg1;
84290   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84291   if (!argp2) {
84292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84293     return ;
84294   }
84295   arg2 = *argp2;
84296   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84297   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84298   {
84299     try {
84300       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84301     } catch (std::out_of_range& e) {
84302       {
84303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84304       };
84305     } catch (std::exception& e) {
84306       {
84307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84308       };
84309     } catch (Dali::DaliException e) {
84310       {
84311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84312       };
84313     } catch (...) {
84314       {
84315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84316       };
84317     }
84318   }
84319
84320 }
84321
84322
84323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84324   unsigned int jresult ;
84325   unsigned int result;
84326
84327   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84328   jresult = result;
84329   return jresult;
84330 }
84331
84332
84333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84334   int jresult ;
84335   int result;
84336
84337   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84338   jresult = (int)result;
84339   return jresult;
84340 }
84341
84342
84343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84344   int jresult ;
84345   int result;
84346
84347   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84348   jresult = (int)result;
84349   return jresult;
84350 }
84351
84352
84353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84354   int jresult ;
84355   int result;
84356
84357   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84358   jresult = (int)result;
84359   return jresult;
84360 }
84361
84362
84363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84364   int jresult ;
84365   int result;
84366
84367   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84368   jresult = (int)result;
84369   return jresult;
84370 }
84371
84372
84373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84374   int jresult ;
84375   int result;
84376
84377   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84378   jresult = (int)result;
84379   return jresult;
84380 }
84381
84382
84383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84384   int jresult ;
84385   int result;
84386
84387   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84388   jresult = (int)result;
84389   return jresult;
84390 }
84391
84392
84393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84394   int jresult ;
84395   int result;
84396
84397   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84398   jresult = (int)result;
84399   return jresult;
84400 }
84401
84402
84403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84404   int jresult ;
84405   int result;
84406
84407   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84408   jresult = (int)result;
84409   return jresult;
84410 }
84411
84412
84413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84414   int jresult ;
84415   int result;
84416
84417   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84418   jresult = (int)result;
84419   return jresult;
84420 }
84421
84422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
84423   int jresult ;
84424   int result;
84425
84426   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
84427   jresult = (int)result;
84428   return jresult;
84429 }
84430
84431
84432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
84433   int jresult ;
84434   int result;
84435
84436   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
84437   jresult = (int)result;
84438   return jresult;
84439 }
84440
84441
84442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
84443   int jresult ;
84444   int result;
84445
84446   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
84447   jresult = (int)result;
84448   return jresult;
84449 }
84450
84451
84452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
84453   int jresult ;
84454   int result;
84455
84456   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
84457   jresult = (int)result;
84458   return jresult;
84459 }
84460
84461
84462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
84463   int jresult ;
84464   int result;
84465
84466   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
84467   jresult = (int)result;
84468   return jresult;
84469 }
84470
84471
84472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84473   int jresult ;
84474   int result;
84475
84476   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84477   jresult = (int)result;
84478   return jresult;
84479 }
84480
84481
84482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84483   int jresult ;
84484   int result;
84485
84486   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84487   jresult = (int)result;
84488   return jresult;
84489 }
84490
84491
84492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84493   int jresult ;
84494   int result;
84495
84496   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84497   jresult = (int)result;
84498   return jresult;
84499 }
84500
84501
84502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84503   int jresult ;
84504   int result;
84505
84506   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84507   jresult = (int)result;
84508   return jresult;
84509 }
84510
84511
84512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84513   int jresult ;
84514   int result;
84515
84516   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84517   jresult = (int)result;
84518   return jresult;
84519 }
84520
84521
84522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84523   int jresult ;
84524   int result;
84525
84526   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84527   jresult = (int)result;
84528   return jresult;
84529 }
84530
84531
84532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84533   int jresult ;
84534   int result;
84535
84536   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84537   jresult = (int)result;
84538   return jresult;
84539 }
84540
84541
84542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84543   int jresult ;
84544   int result;
84545
84546   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84547   jresult = (int)result;
84548   return jresult;
84549 }
84550
84551
84552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84553   int jresult ;
84554   int result;
84555
84556   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84557   jresult = (int)result;
84558   return jresult;
84559 }
84560
84561
84562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84563   int jresult ;
84564   int result;
84565
84566   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84567   jresult = (int)result;
84568   return jresult;
84569 }
84570
84571
84572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84573   void * jresult ;
84574   Dali::Toolkit::TextLabel::Property *result = 0 ;
84575
84576   {
84577     try {
84578       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84579     } catch (std::out_of_range& e) {
84580       {
84581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84582       };
84583     } catch (std::exception& e) {
84584       {
84585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84586       };
84587     } catch (Dali::DaliException e) {
84588       {
84589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84590       };
84591     } catch (...) {
84592       {
84593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84594       };
84595     }
84596   }
84597
84598   jresult = (void *)result;
84599   return jresult;
84600 }
84601
84602
84603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84604   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84605
84606   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84607   {
84608     try {
84609       delete arg1;
84610     } catch (std::out_of_range& e) {
84611       {
84612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84613       };
84614     } catch (std::exception& e) {
84615       {
84616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84617       };
84618     } catch (Dali::DaliException e) {
84619       {
84620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84621       };
84622     } catch (...) {
84623       {
84624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84625       };
84626     }
84627   }
84628
84629 }
84630
84631
84632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84633   void * jresult ;
84634   Dali::Toolkit::TextLabel result;
84635
84636   {
84637     try {
84638       result = Dali::Toolkit::TextLabel::New();
84639     } catch (std::out_of_range& e) {
84640       {
84641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84642       };
84643     } catch (std::exception& e) {
84644       {
84645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84646       };
84647     } catch (Dali::DaliException e) {
84648       {
84649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84650       };
84651     } catch (...) {
84652       {
84653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84654       };
84655     }
84656   }
84657
84658   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84659   return jresult;
84660 }
84661
84662
84663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84664   void * jresult ;
84665   std::string *arg1 = 0 ;
84666   Dali::Toolkit::TextLabel result;
84667
84668   if (!jarg1) {
84669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84670     return 0;
84671   }
84672   std::string arg1_str(jarg1);
84673   arg1 = &arg1_str;
84674   {
84675     try {
84676       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84677     } catch (std::out_of_range& e) {
84678       {
84679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84680       };
84681     } catch (std::exception& e) {
84682       {
84683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84684       };
84685     } catch (Dali::DaliException e) {
84686       {
84687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84688       };
84689     } catch (...) {
84690       {
84691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84692       };
84693     }
84694   }
84695
84696   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84697
84698   //argout typemap for const std::string&
84699
84700   return jresult;
84701 }
84702
84703
84704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84705   void * jresult ;
84706   Dali::Toolkit::TextLabel *result = 0 ;
84707
84708   {
84709     try {
84710       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84711     } catch (std::out_of_range& e) {
84712       {
84713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84714       };
84715     } catch (std::exception& e) {
84716       {
84717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84718       };
84719     } catch (Dali::DaliException e) {
84720       {
84721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84722       };
84723     } catch (...) {
84724       {
84725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84726       };
84727     }
84728   }
84729
84730   jresult = (void *)result;
84731   return jresult;
84732 }
84733
84734
84735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84736   void * jresult ;
84737   Dali::Toolkit::TextLabel *arg1 = 0 ;
84738   Dali::Toolkit::TextLabel *result = 0 ;
84739
84740   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84741   if (!arg1) {
84742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84743     return 0;
84744   }
84745   {
84746     try {
84747       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84748     } catch (std::out_of_range& e) {
84749       {
84750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84751       };
84752     } catch (std::exception& e) {
84753       {
84754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84755       };
84756     } catch (Dali::DaliException e) {
84757       {
84758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84759       };
84760     } catch (...) {
84761       {
84762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84763       };
84764     }
84765   }
84766
84767   jresult = (void *)result;
84768   return jresult;
84769 }
84770
84771
84772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84773   void * jresult ;
84774   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84775   Dali::Toolkit::TextLabel *arg2 = 0 ;
84776   Dali::Toolkit::TextLabel *result = 0 ;
84777
84778   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84779   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84780   if (!arg2) {
84781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84782     return 0;
84783   }
84784   {
84785     try {
84786       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84787     } catch (std::out_of_range& e) {
84788       {
84789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84790       };
84791     } catch (std::exception& e) {
84792       {
84793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84794       };
84795     } catch (Dali::DaliException e) {
84796       {
84797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84798       };
84799     } catch (...) {
84800       {
84801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84802       };
84803     }
84804   }
84805
84806   jresult = (void *)result;
84807   return jresult;
84808 }
84809
84810
84811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84812   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84813
84814   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84815   {
84816     try {
84817       delete arg1;
84818     } catch (std::out_of_range& e) {
84819       {
84820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84821       };
84822     } catch (std::exception& e) {
84823       {
84824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84825       };
84826     } catch (Dali::DaliException e) {
84827       {
84828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84829       };
84830     } catch (...) {
84831       {
84832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84833       };
84834     }
84835   }
84836
84837 }
84838
84839
84840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84841   void * jresult ;
84842   Dali::BaseHandle arg1 ;
84843   Dali::BaseHandle *argp1 ;
84844   Dali::Toolkit::TextLabel result;
84845
84846   argp1 = (Dali::BaseHandle *)jarg1;
84847   if (!argp1) {
84848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84849     return 0;
84850   }
84851   arg1 = *argp1;
84852   {
84853     try {
84854       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84855     } catch (std::out_of_range& e) {
84856       {
84857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84858       };
84859     } catch (std::exception& e) {
84860       {
84861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84862       };
84863     } catch (Dali::DaliException e) {
84864       {
84865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84866       };
84867     } catch (...) {
84868       {
84869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84870       };
84871     }
84872   }
84873
84874   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84875   return jresult;
84876 }
84877
84878
84879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84880   void * jresult ;
84881   Dali::Toolkit::AccessibilityManager *result = 0 ;
84882
84883   {
84884     try {
84885       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84886     } catch (std::out_of_range& e) {
84887       {
84888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84889       };
84890     } catch (std::exception& e) {
84891       {
84892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84893       };
84894     } catch (Dali::DaliException e) {
84895       {
84896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84897       };
84898     } catch (...) {
84899       {
84900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84901       };
84902     }
84903   }
84904
84905   jresult = (void *)result;
84906   return jresult;
84907 }
84908
84909
84910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84911   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84912
84913   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84914   {
84915     try {
84916       delete arg1;
84917     } catch (std::out_of_range& e) {
84918       {
84919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84920       };
84921     } catch (std::exception& e) {
84922       {
84923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84924       };
84925     } catch (Dali::DaliException e) {
84926       {
84927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84928       };
84929     } catch (...) {
84930       {
84931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84932       };
84933     }
84934   }
84935
84936 }
84937
84938
84939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84940   void * jresult ;
84941   Dali::Toolkit::AccessibilityManager result;
84942
84943   {
84944     try {
84945       result = Dali::Toolkit::AccessibilityManager::Get();
84946     } catch (std::out_of_range& e) {
84947       {
84948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84949       };
84950     } catch (std::exception& e) {
84951       {
84952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84953       };
84954     } catch (Dali::DaliException e) {
84955       {
84956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84957       };
84958     } catch (...) {
84959       {
84960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84961       };
84962     }
84963   }
84964
84965   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84966   return jresult;
84967 }
84968
84969
84970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84971   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84972   Dali::Actor arg2 ;
84973   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84974   std::string *arg4 = 0 ;
84975   Dali::Actor *argp2 ;
84976
84977   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84978   argp2 = (Dali::Actor *)jarg2;
84979   if (!argp2) {
84980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84981     return ;
84982   }
84983   arg2 = *argp2;
84984   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84985   if (!jarg4) {
84986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84987     return ;
84988   }
84989   std::string arg4_str(jarg4);
84990   arg4 = &arg4_str;
84991   {
84992     try {
84993       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84994     } catch (std::out_of_range& e) {
84995       {
84996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84997       };
84998     } catch (std::exception& e) {
84999       {
85000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85001       };
85002     } catch (Dali::DaliException e) {
85003       {
85004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85005       };
85006     } catch (...) {
85007       {
85008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85009       };
85010     }
85011   }
85012
85013
85014   //argout typemap for const std::string&
85015
85016 }
85017
85018
85019 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
85020   char * jresult ;
85021   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85022   Dali::Actor arg2 ;
85023   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
85024   Dali::Actor *argp2 ;
85025   std::string result;
85026
85027   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85028   argp2 = (Dali::Actor *)jarg2;
85029   if (!argp2) {
85030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85031     return 0;
85032   }
85033   arg2 = *argp2;
85034   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
85035   {
85036     try {
85037       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
85038     } catch (std::out_of_range& e) {
85039       {
85040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85041       };
85042     } catch (std::exception& e) {
85043       {
85044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85045       };
85046     } catch (Dali::DaliException e) {
85047       {
85048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85049       };
85050     } catch (...) {
85051       {
85052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85053       };
85054     }
85055   }
85056
85057   jresult = SWIG_csharp_string_callback((&result)->c_str());
85058   return jresult;
85059 }
85060
85061
85062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
85063   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85064   Dali::Actor arg2 ;
85065   unsigned int arg3 ;
85066   Dali::Actor *argp2 ;
85067
85068   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85069   argp2 = (Dali::Actor *)jarg2;
85070   if (!argp2) {
85071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85072     return ;
85073   }
85074   arg2 = *argp2;
85075   arg3 = (unsigned int)jarg3;
85076   {
85077     try {
85078       (arg1)->SetFocusOrder(arg2,arg3);
85079     } catch (std::out_of_range& e) {
85080       {
85081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85082       };
85083     } catch (std::exception& e) {
85084       {
85085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85086       };
85087     } catch (Dali::DaliException e) {
85088       {
85089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85090       };
85091     } catch (...) {
85092       {
85093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85094       };
85095     }
85096   }
85097
85098 }
85099
85100
85101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
85102   unsigned int jresult ;
85103   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85104   Dali::Actor arg2 ;
85105   Dali::Actor *argp2 ;
85106   unsigned int result;
85107
85108   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85109   argp2 = (Dali::Actor *)jarg2;
85110   if (!argp2) {
85111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85112     return 0;
85113   }
85114   arg2 = *argp2;
85115   {
85116     try {
85117       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
85118     } catch (std::out_of_range& e) {
85119       {
85120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85121       };
85122     } catch (std::exception& e) {
85123       {
85124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85125       };
85126     } catch (Dali::DaliException e) {
85127       {
85128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85129       };
85130     } catch (...) {
85131       {
85132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85133       };
85134     }
85135   }
85136
85137   jresult = result;
85138   return jresult;
85139 }
85140
85141
85142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
85143   unsigned int jresult ;
85144   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85145   unsigned int result;
85146
85147   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85148   {
85149     try {
85150       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85151     } catch (std::out_of_range& e) {
85152       {
85153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85154       };
85155     } catch (std::exception& e) {
85156       {
85157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85158       };
85159     } catch (Dali::DaliException e) {
85160       {
85161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85162       };
85163     } catch (...) {
85164       {
85165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85166       };
85167     }
85168   }
85169
85170   jresult = result;
85171   return jresult;
85172 }
85173
85174
85175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85176   void * jresult ;
85177   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85178   unsigned int arg2 ;
85179   Dali::Actor result;
85180
85181   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85182   arg2 = (unsigned int)jarg2;
85183   {
85184     try {
85185       result = (arg1)->GetActorByFocusOrder(arg2);
85186     } catch (std::out_of_range& e) {
85187       {
85188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85189       };
85190     } catch (std::exception& e) {
85191       {
85192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85193       };
85194     } catch (Dali::DaliException e) {
85195       {
85196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85197       };
85198     } catch (...) {
85199       {
85200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85201       };
85202     }
85203   }
85204
85205   jresult = new Dali::Actor((const Dali::Actor &)result);
85206   return jresult;
85207 }
85208
85209
85210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85211   unsigned int jresult ;
85212   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85213   Dali::Actor arg2 ;
85214   Dali::Actor *argp2 ;
85215   bool result;
85216
85217   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85218   argp2 = (Dali::Actor *)jarg2;
85219   if (!argp2) {
85220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85221     return 0;
85222   }
85223   arg2 = *argp2;
85224   {
85225     try {
85226       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85227     } catch (std::out_of_range& e) {
85228       {
85229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85230       };
85231     } catch (std::exception& e) {
85232       {
85233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85234       };
85235     } catch (Dali::DaliException e) {
85236       {
85237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85238       };
85239     } catch (...) {
85240       {
85241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85242       };
85243     }
85244   }
85245
85246   jresult = result;
85247   return jresult;
85248 }
85249
85250
85251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85252   void * jresult ;
85253   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85254   Dali::Actor result;
85255
85256   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85257   {
85258     try {
85259       result = (arg1)->GetCurrentFocusActor();
85260     } catch (std::out_of_range& e) {
85261       {
85262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85263       };
85264     } catch (std::exception& e) {
85265       {
85266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85267       };
85268     } catch (Dali::DaliException e) {
85269       {
85270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85271       };
85272     } catch (...) {
85273       {
85274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85275       };
85276     }
85277   }
85278
85279   jresult = new Dali::Actor((const Dali::Actor &)result);
85280   return jresult;
85281 }
85282
85283
85284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85285   void * jresult ;
85286   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85287   Dali::Actor result;
85288
85289   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85290   {
85291     try {
85292       result = (arg1)->GetCurrentFocusGroup();
85293     } catch (std::out_of_range& e) {
85294       {
85295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85296       };
85297     } catch (std::exception& e) {
85298       {
85299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85300       };
85301     } catch (Dali::DaliException e) {
85302       {
85303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85304       };
85305     } catch (...) {
85306       {
85307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85308       };
85309     }
85310   }
85311
85312   jresult = new Dali::Actor((const Dali::Actor &)result);
85313   return jresult;
85314 }
85315
85316
85317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85318   unsigned int jresult ;
85319   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85320   unsigned int result;
85321
85322   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85323   {
85324     try {
85325       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85326     } catch (std::out_of_range& e) {
85327       {
85328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85329       };
85330     } catch (std::exception& e) {
85331       {
85332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85333       };
85334     } catch (Dali::DaliException e) {
85335       {
85336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85337       };
85338     } catch (...) {
85339       {
85340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85341       };
85342     }
85343   }
85344
85345   jresult = result;
85346   return jresult;
85347 }
85348
85349
85350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85351   unsigned int jresult ;
85352   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85353   bool result;
85354
85355   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85356   {
85357     try {
85358       result = (bool)(arg1)->MoveFocusForward();
85359     } catch (std::out_of_range& e) {
85360       {
85361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85362       };
85363     } catch (std::exception& e) {
85364       {
85365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85366       };
85367     } catch (Dali::DaliException e) {
85368       {
85369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85370       };
85371     } catch (...) {
85372       {
85373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85374       };
85375     }
85376   }
85377
85378   jresult = result;
85379   return jresult;
85380 }
85381
85382
85383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85384   unsigned int jresult ;
85385   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85386   bool result;
85387
85388   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85389   {
85390     try {
85391       result = (bool)(arg1)->MoveFocusBackward();
85392     } catch (std::out_of_range& e) {
85393       {
85394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85395       };
85396     } catch (std::exception& e) {
85397       {
85398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85399       };
85400     } catch (Dali::DaliException e) {
85401       {
85402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85403       };
85404     } catch (...) {
85405       {
85406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85407       };
85408     }
85409   }
85410
85411   jresult = result;
85412   return jresult;
85413 }
85414
85415
85416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85417   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85418
85419   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85420   {
85421     try {
85422       (arg1)->ClearFocus();
85423     } catch (std::out_of_range& e) {
85424       {
85425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85426       };
85427     } catch (std::exception& e) {
85428       {
85429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85430       };
85431     } catch (Dali::DaliException e) {
85432       {
85433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85434       };
85435     } catch (...) {
85436       {
85437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85438       };
85439     }
85440   }
85441
85442 }
85443
85444
85445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85446   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85447
85448   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85449   {
85450     try {
85451       (arg1)->Reset();
85452     } catch (std::out_of_range& e) {
85453       {
85454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85455       };
85456     } catch (std::exception& e) {
85457       {
85458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85459       };
85460     } catch (Dali::DaliException e) {
85461       {
85462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85463       };
85464     } catch (...) {
85465       {
85466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85467       };
85468     }
85469   }
85470
85471 }
85472
85473
85474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85475   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85476   Dali::Actor arg2 ;
85477   bool arg3 ;
85478   Dali::Actor *argp2 ;
85479
85480   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85481   argp2 = (Dali::Actor *)jarg2;
85482   if (!argp2) {
85483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85484     return ;
85485   }
85486   arg2 = *argp2;
85487   arg3 = jarg3 ? true : false;
85488   {
85489     try {
85490       (arg1)->SetFocusGroup(arg2,arg3);
85491     } catch (std::out_of_range& e) {
85492       {
85493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85494       };
85495     } catch (std::exception& e) {
85496       {
85497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85498       };
85499     } catch (Dali::DaliException e) {
85500       {
85501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85502       };
85503     } catch (...) {
85504       {
85505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85506       };
85507     }
85508   }
85509
85510 }
85511
85512
85513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85514   unsigned int jresult ;
85515   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85516   Dali::Actor arg2 ;
85517   Dali::Actor *argp2 ;
85518   bool result;
85519
85520   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85521   argp2 = (Dali::Actor *)jarg2;
85522   if (!argp2) {
85523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85524     return 0;
85525   }
85526   arg2 = *argp2;
85527   {
85528     try {
85529       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85530     } catch (std::out_of_range& e) {
85531       {
85532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85533       };
85534     } catch (std::exception& e) {
85535       {
85536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85537       };
85538     } catch (Dali::DaliException e) {
85539       {
85540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85541       };
85542     } catch (...) {
85543       {
85544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85545       };
85546     }
85547   }
85548
85549   jresult = result;
85550   return jresult;
85551 }
85552
85553
85554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85555   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85556   bool arg2 ;
85557
85558   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85559   arg2 = jarg2 ? true : false;
85560   {
85561     try {
85562       (arg1)->SetGroupMode(arg2);
85563     } catch (std::out_of_range& e) {
85564       {
85565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85566       };
85567     } catch (std::exception& e) {
85568       {
85569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85570       };
85571     } catch (Dali::DaliException e) {
85572       {
85573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85574       };
85575     } catch (...) {
85576       {
85577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85578       };
85579     }
85580   }
85581
85582 }
85583
85584
85585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85586   unsigned int jresult ;
85587   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85588   bool result;
85589
85590   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85591   {
85592     try {
85593       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85594     } catch (std::out_of_range& e) {
85595       {
85596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85597       };
85598     } catch (std::exception& e) {
85599       {
85600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85601       };
85602     } catch (Dali::DaliException e) {
85603       {
85604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85605       };
85606     } catch (...) {
85607       {
85608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85609       };
85610     }
85611   }
85612
85613   jresult = result;
85614   return jresult;
85615 }
85616
85617
85618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85619   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85620   bool arg2 ;
85621
85622   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85623   arg2 = jarg2 ? true : false;
85624   {
85625     try {
85626       (arg1)->SetWrapMode(arg2);
85627     } catch (std::out_of_range& e) {
85628       {
85629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85630       };
85631     } catch (std::exception& e) {
85632       {
85633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85634       };
85635     } catch (Dali::DaliException e) {
85636       {
85637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85638       };
85639     } catch (...) {
85640       {
85641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85642       };
85643     }
85644   }
85645
85646 }
85647
85648
85649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85650   unsigned int jresult ;
85651   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85652   bool result;
85653
85654   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85655   {
85656     try {
85657       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85658     } catch (std::out_of_range& e) {
85659       {
85660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85661       };
85662     } catch (std::exception& e) {
85663       {
85664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85665       };
85666     } catch (Dali::DaliException e) {
85667       {
85668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85669       };
85670     } catch (...) {
85671       {
85672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85673       };
85674     }
85675   }
85676
85677   jresult = result;
85678   return jresult;
85679 }
85680
85681
85682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85683   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85684   Dali::Actor arg2 ;
85685   Dali::Actor *argp2 ;
85686
85687   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85688   argp2 = (Dali::Actor *)jarg2;
85689   if (!argp2) {
85690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85691     return ;
85692   }
85693   arg2 = *argp2;
85694   {
85695     try {
85696       (arg1)->SetFocusIndicatorActor(arg2);
85697     } catch (std::out_of_range& e) {
85698       {
85699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85700       };
85701     } catch (std::exception& e) {
85702       {
85703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85704       };
85705     } catch (Dali::DaliException e) {
85706       {
85707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85708       };
85709     } catch (...) {
85710       {
85711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85712       };
85713     }
85714   }
85715
85716 }
85717
85718
85719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85720   void * jresult ;
85721   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85722   Dali::Actor result;
85723
85724   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85725   {
85726     try {
85727       result = (arg1)->GetFocusIndicatorActor();
85728     } catch (std::out_of_range& e) {
85729       {
85730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85731       };
85732     } catch (std::exception& e) {
85733       {
85734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85735       };
85736     } catch (Dali::DaliException e) {
85737       {
85738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85739       };
85740     } catch (...) {
85741       {
85742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85743       };
85744     }
85745   }
85746
85747   jresult = new Dali::Actor((const Dali::Actor &)result);
85748   return jresult;
85749 }
85750
85751
85752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85753   void * jresult ;
85754   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85755   Dali::Actor arg2 ;
85756   Dali::Actor *argp2 ;
85757   Dali::Actor result;
85758
85759   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85760   argp2 = (Dali::Actor *)jarg2;
85761   if (!argp2) {
85762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85763     return 0;
85764   }
85765   arg2 = *argp2;
85766   {
85767     try {
85768       result = (arg1)->GetFocusGroup(arg2);
85769     } catch (std::out_of_range& e) {
85770       {
85771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85772       };
85773     } catch (std::exception& e) {
85774       {
85775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85776       };
85777     } catch (Dali::DaliException e) {
85778       {
85779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85780       };
85781     } catch (...) {
85782       {
85783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85784       };
85785     }
85786   }
85787
85788   jresult = new Dali::Actor((const Dali::Actor &)result);
85789   return jresult;
85790 }
85791
85792
85793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85794   void * jresult ;
85795   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85796   Dali::Vector2 result;
85797
85798   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85799   {
85800     try {
85801       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85802     } catch (std::out_of_range& e) {
85803       {
85804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85805       };
85806     } catch (std::exception& e) {
85807       {
85808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85809       };
85810     } catch (Dali::DaliException e) {
85811       {
85812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85813       };
85814     } catch (...) {
85815       {
85816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85817       };
85818     }
85819   }
85820
85821   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85822   return jresult;
85823 }
85824
85825
85826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85827   void * jresult ;
85828   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85829   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85830
85831   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85832   {
85833     try {
85834       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85835     } catch (std::out_of_range& e) {
85836       {
85837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85838       };
85839     } catch (std::exception& e) {
85840       {
85841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85842       };
85843     } catch (Dali::DaliException e) {
85844       {
85845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85846       };
85847     } catch (...) {
85848       {
85849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85850       };
85851     }
85852   }
85853
85854   jresult = (void *)result;
85855   return jresult;
85856 }
85857
85858
85859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85860   void * jresult ;
85861   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85862   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85863
85864   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85865   {
85866     try {
85867       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85868     } catch (std::out_of_range& e) {
85869       {
85870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85871       };
85872     } catch (std::exception& e) {
85873       {
85874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85875       };
85876     } catch (Dali::DaliException e) {
85877       {
85878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85879       };
85880     } catch (...) {
85881       {
85882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85883       };
85884     }
85885   }
85886
85887   jresult = (void *)result;
85888   return jresult;
85889 }
85890
85891
85892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85893   void * jresult ;
85894   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85895   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85896
85897   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85898   {
85899     try {
85900       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85901     } catch (std::out_of_range& e) {
85902       {
85903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85904       };
85905     } catch (std::exception& e) {
85906       {
85907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85908       };
85909     } catch (Dali::DaliException e) {
85910       {
85911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85912       };
85913     } catch (...) {
85914       {
85915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85916       };
85917     }
85918   }
85919
85920   jresult = (void *)result;
85921   return jresult;
85922 }
85923
85924
85925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85926   void * jresult ;
85927   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85928   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85929
85930   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85931   {
85932     try {
85933       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85934     } catch (std::out_of_range& e) {
85935       {
85936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85937       };
85938     } catch (std::exception& e) {
85939       {
85940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85941       };
85942     } catch (Dali::DaliException e) {
85943       {
85944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85945       };
85946     } catch (...) {
85947       {
85948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85949       };
85950     }
85951   }
85952
85953   jresult = (void *)result;
85954   return jresult;
85955 }
85956
85957
85958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85959   void * jresult ;
85960   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85961   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85962
85963   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85964   {
85965     try {
85966       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85967     } catch (std::out_of_range& e) {
85968       {
85969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85970       };
85971     } catch (std::exception& e) {
85972       {
85973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85974       };
85975     } catch (Dali::DaliException e) {
85976       {
85977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85978       };
85979     } catch (...) {
85980       {
85981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85982       };
85983     }
85984   }
85985
85986   jresult = (void *)result;
85987   return jresult;
85988 }
85989
85990
85991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85992   void * jresult ;
85993   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85994   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85995
85996   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85997   {
85998     try {
85999       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
86000     } catch (std::out_of_range& e) {
86001       {
86002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86003       };
86004     } catch (std::exception& e) {
86005       {
86006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86007       };
86008     } catch (Dali::DaliException e) {
86009       {
86010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86011       };
86012     } catch (...) {
86013       {
86014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86015       };
86016     }
86017   }
86018
86019   jresult = (void *)result;
86020   return jresult;
86021 }
86022
86023
86024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
86025   void * jresult ;
86026   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86027   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86028
86029   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86030   {
86031     try {
86032       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
86033     } catch (std::out_of_range& e) {
86034       {
86035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86036       };
86037     } catch (std::exception& e) {
86038       {
86039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86040       };
86041     } catch (Dali::DaliException e) {
86042       {
86043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86044       };
86045     } catch (...) {
86046       {
86047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86048       };
86049     }
86050   }
86051
86052   jresult = (void *)result;
86053   return jresult;
86054 }
86055
86056
86057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
86058   void * jresult ;
86059   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86060   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86061
86062   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86063   {
86064     try {
86065       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
86066     } catch (std::out_of_range& e) {
86067       {
86068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86069       };
86070     } catch (std::exception& e) {
86071       {
86072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86073       };
86074     } catch (Dali::DaliException e) {
86075       {
86076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86077       };
86078     } catch (...) {
86079       {
86080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86081       };
86082     }
86083   }
86084
86085   jresult = (void *)result;
86086   return jresult;
86087 }
86088
86089
86090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
86091   void * jresult ;
86092   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86093   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86094
86095   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86096   {
86097     try {
86098       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
86099     } catch (std::out_of_range& e) {
86100       {
86101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86102       };
86103     } catch (std::exception& e) {
86104       {
86105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86106       };
86107     } catch (Dali::DaliException e) {
86108       {
86109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86110       };
86111     } catch (...) {
86112       {
86113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86114       };
86115     }
86116   }
86117
86118   jresult = (void *)result;
86119   return jresult;
86120 }
86121
86122
86123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
86124   void * jresult ;
86125   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86126   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86127
86128   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86129   {
86130     try {
86131       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
86132     } catch (std::out_of_range& e) {
86133       {
86134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86135       };
86136     } catch (std::exception& e) {
86137       {
86138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86139       };
86140     } catch (Dali::DaliException e) {
86141       {
86142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86143       };
86144     } catch (...) {
86145       {
86146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86147       };
86148     }
86149   }
86150
86151   jresult = (void *)result;
86152   return jresult;
86153 }
86154
86155
86156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86157   void * jresult ;
86158   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86159   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86160
86161   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86162   {
86163     try {
86164       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86165     } catch (std::out_of_range& e) {
86166       {
86167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86168       };
86169     } catch (std::exception& e) {
86170       {
86171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86172       };
86173     } catch (Dali::DaliException e) {
86174       {
86175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86176       };
86177     } catch (...) {
86178       {
86179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86180       };
86181     }
86182   }
86183
86184   jresult = (void *)result;
86185   return jresult;
86186 }
86187
86188
86189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86190   void * jresult ;
86191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86192   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86193
86194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86195   {
86196     try {
86197       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86198     } catch (std::out_of_range& e) {
86199       {
86200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86201       };
86202     } catch (std::exception& e) {
86203       {
86204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86205       };
86206     } catch (Dali::DaliException e) {
86207       {
86208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86209       };
86210     } catch (...) {
86211       {
86212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86213       };
86214     }
86215   }
86216
86217   jresult = (void *)result;
86218   return jresult;
86219 }
86220
86221
86222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86223   void * jresult ;
86224   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86225   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86226
86227   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86228   {
86229     try {
86230       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86231     } catch (std::out_of_range& e) {
86232       {
86233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86234       };
86235     } catch (std::exception& e) {
86236       {
86237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86238       };
86239     } catch (Dali::DaliException e) {
86240       {
86241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86242       };
86243     } catch (...) {
86244       {
86245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86246       };
86247     }
86248   }
86249
86250   jresult = (void *)result;
86251   return jresult;
86252 }
86253
86254
86255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86256   void * jresult ;
86257   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86258   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86259
86260   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86261   {
86262     try {
86263       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86264     } catch (std::out_of_range& e) {
86265       {
86266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86267       };
86268     } catch (std::exception& e) {
86269       {
86270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86271       };
86272     } catch (Dali::DaliException e) {
86273       {
86274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86275       };
86276     } catch (...) {
86277       {
86278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86279       };
86280     }
86281   }
86282
86283   jresult = (void *)result;
86284   return jresult;
86285 }
86286
86287
86288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86289   void * jresult ;
86290   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86291   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86292
86293   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86294   {
86295     try {
86296       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86297     } catch (std::out_of_range& e) {
86298       {
86299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86300       };
86301     } catch (std::exception& e) {
86302       {
86303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86304       };
86305     } catch (Dali::DaliException e) {
86306       {
86307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86308       };
86309     } catch (...) {
86310       {
86311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86312       };
86313     }
86314   }
86315
86316   jresult = (void *)result;
86317   return jresult;
86318 }
86319
86320
86321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86322   void * jresult ;
86323   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86324   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86325
86326   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86327   {
86328     try {
86329       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86330     } catch (std::out_of_range& e) {
86331       {
86332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86333       };
86334     } catch (std::exception& e) {
86335       {
86336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86337       };
86338     } catch (Dali::DaliException e) {
86339       {
86340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86341       };
86342     } catch (...) {
86343       {
86344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86345       };
86346     }
86347   }
86348
86349   jresult = (void *)result;
86350   return jresult;
86351 }
86352
86353
86354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86355   void * jresult ;
86356   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86357   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86358
86359   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86360   {
86361     try {
86362       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86363     } catch (std::out_of_range& e) {
86364       {
86365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86366       };
86367     } catch (std::exception& e) {
86368       {
86369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86370       };
86371     } catch (Dali::DaliException e) {
86372       {
86373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86374       };
86375     } catch (...) {
86376       {
86377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86378       };
86379     }
86380   }
86381
86382   jresult = (void *)result;
86383   return jresult;
86384 }
86385
86386
86387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86388   void * jresult ;
86389   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86390   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86391
86392   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86393   {
86394     try {
86395       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86396     } catch (std::out_of_range& e) {
86397       {
86398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86399       };
86400     } catch (std::exception& e) {
86401       {
86402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86403       };
86404     } catch (Dali::DaliException e) {
86405       {
86406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86407       };
86408     } catch (...) {
86409       {
86410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86411       };
86412     }
86413   }
86414
86415   jresult = (void *)result;
86416   return jresult;
86417 }
86418
86419
86420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86421   void * jresult ;
86422   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86423   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86424
86425   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86426   {
86427     try {
86428       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86429     } catch (std::out_of_range& e) {
86430       {
86431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86432       };
86433     } catch (std::exception& e) {
86434       {
86435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86436       };
86437     } catch (Dali::DaliException e) {
86438       {
86439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86440       };
86441     } catch (...) {
86442       {
86443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86444       };
86445     }
86446   }
86447
86448   jresult = (void *)result;
86449   return jresult;
86450 }
86451
86452
86453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86454   void * jresult ;
86455   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86456   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86457
86458   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86459   {
86460     try {
86461       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86462     } catch (std::out_of_range& e) {
86463       {
86464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86465       };
86466     } catch (std::exception& e) {
86467       {
86468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86469       };
86470     } catch (Dali::DaliException e) {
86471       {
86472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86473       };
86474     } catch (...) {
86475       {
86476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86477       };
86478     }
86479   }
86480
86481   jresult = (void *)result;
86482   return jresult;
86483 }
86484
86485
86486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86487   void * jresult ;
86488   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86489   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86490
86491   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86492   {
86493     try {
86494       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86495     } catch (std::out_of_range& e) {
86496       {
86497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86498       };
86499     } catch (std::exception& e) {
86500       {
86501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86502       };
86503     } catch (Dali::DaliException e) {
86504       {
86505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86506       };
86507     } catch (...) {
86508       {
86509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86510       };
86511     }
86512   }
86513
86514   jresult = (void *)result;
86515   return jresult;
86516 }
86517
86518
86519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86520   void * jresult ;
86521   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86522   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86523
86524   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86525   {
86526     try {
86527       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86528     } catch (std::out_of_range& e) {
86529       {
86530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86531       };
86532     } catch (std::exception& e) {
86533       {
86534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86535       };
86536     } catch (Dali::DaliException e) {
86537       {
86538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86539       };
86540     } catch (...) {
86541       {
86542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86543       };
86544     }
86545   }
86546
86547   jresult = (void *)result;
86548   return jresult;
86549 }
86550
86551
86552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86553   void * jresult ;
86554   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86555   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86556
86557   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86558   {
86559     try {
86560       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86561     } catch (std::out_of_range& e) {
86562       {
86563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86564       };
86565     } catch (std::exception& e) {
86566       {
86567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86568       };
86569     } catch (Dali::DaliException e) {
86570       {
86571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86572       };
86573     } catch (...) {
86574       {
86575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86576       };
86577     }
86578   }
86579
86580   jresult = (void *)result;
86581   return jresult;
86582 }
86583
86584
86585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86586   void * jresult ;
86587   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86588   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86589
86590   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86591   {
86592     try {
86593       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86594     } catch (std::out_of_range& e) {
86595       {
86596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86597       };
86598     } catch (std::exception& e) {
86599       {
86600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86601       };
86602     } catch (Dali::DaliException e) {
86603       {
86604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86605       };
86606     } catch (...) {
86607       {
86608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86609       };
86610     }
86611   }
86612
86613   jresult = (void *)result;
86614   return jresult;
86615 }
86616
86617
86618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86619   void * jresult ;
86620   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86621   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86622
86623   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86624   {
86625     try {
86626       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86627     } catch (std::out_of_range& e) {
86628       {
86629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86630       };
86631     } catch (std::exception& e) {
86632       {
86633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86634       };
86635     } catch (Dali::DaliException e) {
86636       {
86637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86638       };
86639     } catch (...) {
86640       {
86641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86642       };
86643     }
86644   }
86645
86646   jresult = (void *)result;
86647   return jresult;
86648 }
86649
86650
86651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86652   void * jresult ;
86653   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86654   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86655
86656   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86657   {
86658     try {
86659       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86660     } catch (std::out_of_range& e) {
86661       {
86662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86663       };
86664     } catch (std::exception& e) {
86665       {
86666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86667       };
86668     } catch (Dali::DaliException e) {
86669       {
86670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86671       };
86672     } catch (...) {
86673       {
86674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86675       };
86676     }
86677   }
86678
86679   jresult = (void *)result;
86680   return jresult;
86681 }
86682
86683
86684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86685   void * jresult ;
86686   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86687   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86688
86689   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86690   {
86691     try {
86692       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86693     } catch (std::out_of_range& e) {
86694       {
86695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86696       };
86697     } catch (std::exception& e) {
86698       {
86699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86700       };
86701     } catch (Dali::DaliException e) {
86702       {
86703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86704       };
86705     } catch (...) {
86706       {
86707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86708       };
86709     }
86710   }
86711
86712   jresult = (void *)result;
86713   return jresult;
86714 }
86715
86716
86717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86718   void * jresult ;
86719   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86720   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86721
86722   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86723   {
86724     try {
86725       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86726     } catch (std::out_of_range& e) {
86727       {
86728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86729       };
86730     } catch (std::exception& e) {
86731       {
86732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86733       };
86734     } catch (Dali::DaliException e) {
86735       {
86736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86737       };
86738     } catch (...) {
86739       {
86740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86741       };
86742     }
86743   }
86744
86745   jresult = (void *)result;
86746   return jresult;
86747 }
86748
86749
86750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86751   void * jresult ;
86752   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86753   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86754
86755   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86756   {
86757     try {
86758       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86759     } catch (std::out_of_range& e) {
86760       {
86761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86762       };
86763     } catch (std::exception& e) {
86764       {
86765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86766       };
86767     } catch (Dali::DaliException e) {
86768       {
86769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86770       };
86771     } catch (...) {
86772       {
86773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86774       };
86775     }
86776   }
86777
86778   jresult = (void *)result;
86779   return jresult;
86780 }
86781
86782
86783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86784   void * jresult ;
86785   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86786   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86787
86788   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86789   {
86790     try {
86791       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86792     } catch (std::out_of_range& e) {
86793       {
86794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86795       };
86796     } catch (std::exception& e) {
86797       {
86798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86799       };
86800     } catch (Dali::DaliException e) {
86801       {
86802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86803       };
86804     } catch (...) {
86805       {
86806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86807       };
86808     }
86809   }
86810
86811   jresult = (void *)result;
86812   return jresult;
86813 }
86814
86815
86816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86817   void * jresult ;
86818   Dali::Toolkit::StyleManager *result = 0 ;
86819
86820   {
86821     try {
86822       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86823     } catch (std::out_of_range& e) {
86824       {
86825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86826       };
86827     } catch (std::exception& e) {
86828       {
86829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86830       };
86831     } catch (Dali::DaliException e) {
86832       {
86833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86834       };
86835     } catch (...) {
86836       {
86837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86838       };
86839     }
86840   }
86841
86842   jresult = (void *)result;
86843   return jresult;
86844 }
86845
86846
86847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86848   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86849
86850   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86851   {
86852     try {
86853       delete arg1;
86854     } catch (std::out_of_range& e) {
86855       {
86856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86857       };
86858     } catch (std::exception& e) {
86859       {
86860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86861       };
86862     } catch (Dali::DaliException e) {
86863       {
86864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86865       };
86866     } catch (...) {
86867       {
86868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86869       };
86870     }
86871   }
86872
86873 }
86874
86875
86876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86877   void * jresult ;
86878   Dali::Toolkit::StyleManager result;
86879
86880   {
86881     try {
86882       result = Dali::Toolkit::StyleManager::Get();
86883     } catch (std::out_of_range& e) {
86884       {
86885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86886       };
86887     } catch (std::exception& e) {
86888       {
86889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86890       };
86891     } catch (Dali::DaliException e) {
86892       {
86893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86894       };
86895     } catch (...) {
86896       {
86897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86898       };
86899     }
86900   }
86901
86902   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86903   return jresult;
86904 }
86905
86906
86907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86908   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86909   std::string *arg2 = 0 ;
86910
86911   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86912   if (!jarg2) {
86913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86914     return ;
86915   }
86916   std::string arg2_str(jarg2);
86917   arg2 = &arg2_str;
86918   {
86919     try {
86920       (arg1)->ApplyTheme((std::string const &)*arg2);
86921     } catch (std::out_of_range& e) {
86922       {
86923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86924       };
86925     } catch (std::exception& e) {
86926       {
86927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86928       };
86929     } catch (Dali::DaliException e) {
86930       {
86931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86932       };
86933     } catch (...) {
86934       {
86935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86936       };
86937     }
86938   }
86939
86940
86941   //argout typemap for const std::string&
86942
86943 }
86944
86945
86946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86947   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86948
86949   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86950   {
86951     try {
86952       (arg1)->ApplyDefaultTheme();
86953     } catch (std::out_of_range& e) {
86954       {
86955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86956       };
86957     } catch (std::exception& e) {
86958       {
86959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86960       };
86961     } catch (Dali::DaliException e) {
86962       {
86963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86964       };
86965     } catch (...) {
86966       {
86967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86968       };
86969     }
86970   }
86971
86972 }
86973
86974
86975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86976   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86977   std::string *arg2 = 0 ;
86978   Dali::Property::Value *arg3 = 0 ;
86979
86980   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86981   if (!jarg2) {
86982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86983     return ;
86984   }
86985   std::string arg2_str(jarg2);
86986   arg2 = &arg2_str;
86987   arg3 = (Dali::Property::Value *)jarg3;
86988   if (!arg3) {
86989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86990     return ;
86991   }
86992   {
86993     try {
86994       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86995     } catch (std::out_of_range& e) {
86996       {
86997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86998       };
86999     } catch (std::exception& e) {
87000       {
87001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87002       };
87003     } catch (Dali::DaliException e) {
87004       {
87005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87006       };
87007     } catch (...) {
87008       {
87009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87010       };
87011     }
87012   }
87013
87014
87015   //argout typemap for const std::string&
87016
87017 }
87018
87019
87020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
87021   unsigned int jresult ;
87022   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87023   std::string *arg2 = 0 ;
87024   Dali::Property::Value *arg3 = 0 ;
87025   bool result;
87026
87027   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87028   if (!jarg2) {
87029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87030     return 0;
87031   }
87032   std::string arg2_str(jarg2);
87033   arg2 = &arg2_str;
87034   arg3 = (Dali::Property::Value *)jarg3;
87035   if (!arg3) {
87036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
87037     return 0;
87038   }
87039   {
87040     try {
87041       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
87042     } catch (std::out_of_range& e) {
87043       {
87044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87045       };
87046     } catch (std::exception& e) {
87047       {
87048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87049       };
87050     } catch (Dali::DaliException e) {
87051       {
87052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87053       };
87054     } catch (...) {
87055       {
87056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87057       };
87058     }
87059   }
87060
87061   jresult = result;
87062
87063   //argout typemap for const std::string&
87064
87065   return jresult;
87066 }
87067
87068
87069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
87070   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87071   Dali::Toolkit::Control arg2 ;
87072   std::string *arg3 = 0 ;
87073   std::string *arg4 = 0 ;
87074   Dali::Toolkit::Control *argp2 ;
87075
87076   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87077   argp2 = (Dali::Toolkit::Control *)jarg2;
87078   if (!argp2) {
87079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87080     return ;
87081   }
87082   arg2 = *argp2;
87083   if (!jarg3) {
87084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87085     return ;
87086   }
87087   std::string arg3_str(jarg3);
87088   arg3 = &arg3_str;
87089   if (!jarg4) {
87090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87091     return ;
87092   }
87093   std::string arg4_str(jarg4);
87094   arg4 = &arg4_str;
87095   {
87096     try {
87097       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
87098     } catch (std::out_of_range& e) {
87099       {
87100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87101       };
87102     } catch (std::exception& e) {
87103       {
87104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87105       };
87106     } catch (Dali::DaliException e) {
87107       {
87108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87109       };
87110     } catch (...) {
87111       {
87112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87113       };
87114     }
87115   }
87116
87117
87118   //argout typemap for const std::string&
87119
87120
87121   //argout typemap for const std::string&
87122
87123 }
87124
87125
87126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
87127   void * jresult ;
87128   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87129   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
87130
87131   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87132   {
87133     try {
87134       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
87135     } catch (std::out_of_range& e) {
87136       {
87137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87138       };
87139     } catch (std::exception& e) {
87140       {
87141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87142       };
87143     } catch (Dali::DaliException e) {
87144       {
87145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87146       };
87147     } catch (...) {
87148       {
87149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87150       };
87151     }
87152   }
87153
87154   jresult = (void *)result;
87155   return jresult;
87156 }
87157
87158
87159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87160   int jresult ;
87161   int result;
87162
87163   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87164   jresult = (int)result;
87165   return jresult;
87166 }
87167
87168
87169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87170   int jresult ;
87171   int result;
87172
87173   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87174   jresult = (int)result;
87175   return jresult;
87176 }
87177
87178
87179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87180   int jresult ;
87181   int result;
87182
87183   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87184   jresult = (int)result;
87185   return jresult;
87186 }
87187
87188
87189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87190   int jresult ;
87191   int result;
87192
87193   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87194   jresult = (int)result;
87195   return jresult;
87196 }
87197
87198
87199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87200   int jresult ;
87201   int result;
87202
87203   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87204   jresult = (int)result;
87205   return jresult;
87206 }
87207
87208
87209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87210   int jresult ;
87211   int result;
87212
87213   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87214   jresult = (int)result;
87215   return jresult;
87216 }
87217
87218
87219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87220   int jresult ;
87221   int result;
87222
87223   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87224   jresult = (int)result;
87225   return jresult;
87226 }
87227
87228
87229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87230   int jresult ;
87231   int result;
87232
87233   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87234   jresult = (int)result;
87235   return jresult;
87236 }
87237
87238
87239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87240   int jresult ;
87241   int result;
87242
87243   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87244   jresult = (int)result;
87245   return jresult;
87246 }
87247
87248
87249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87250   int jresult ;
87251   int result;
87252
87253   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87254   jresult = (int)result;
87255   return jresult;
87256 }
87257
87258
87259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87260   int jresult ;
87261   int result;
87262
87263   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87264   jresult = (int)result;
87265   return jresult;
87266 }
87267
87268
87269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87270   int jresult ;
87271   int result;
87272
87273   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87274   jresult = (int)result;
87275   return jresult;
87276 }
87277
87278
87279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87280   int jresult ;
87281   int result;
87282
87283   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87284   jresult = (int)result;
87285   return jresult;
87286 }
87287
87288
87289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87290   int jresult ;
87291   int result;
87292
87293   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87294   jresult = (int)result;
87295   return jresult;
87296 }
87297
87298
87299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87300   int jresult ;
87301   int result;
87302
87303   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87304   jresult = (int)result;
87305   return jresult;
87306 }
87307
87308
87309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87310   void * jresult ;
87311   Dali::Toolkit::Slider::Property *result = 0 ;
87312
87313   {
87314     try {
87315       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87316     } catch (std::out_of_range& e) {
87317       {
87318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87319       };
87320     } catch (std::exception& e) {
87321       {
87322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87323       };
87324     } catch (Dali::DaliException e) {
87325       {
87326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87327       };
87328     } catch (...) {
87329       {
87330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87331       };
87332     }
87333   }
87334
87335   jresult = (void *)result;
87336   return jresult;
87337 }
87338
87339
87340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87341   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87342
87343   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87344   {
87345     try {
87346       delete arg1;
87347     } catch (std::out_of_range& e) {
87348       {
87349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87350       };
87351     } catch (std::exception& e) {
87352       {
87353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87354       };
87355     } catch (Dali::DaliException e) {
87356       {
87357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87358       };
87359     } catch (...) {
87360       {
87361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87362       };
87363     }
87364   }
87365
87366 }
87367
87368
87369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87370   void * jresult ;
87371   Dali::Toolkit::Slider result;
87372
87373   {
87374     try {
87375       result = Dali::Toolkit::Slider::New();
87376     } catch (std::out_of_range& e) {
87377       {
87378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87379       };
87380     } catch (std::exception& e) {
87381       {
87382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87383       };
87384     } catch (Dali::DaliException e) {
87385       {
87386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87387       };
87388     } catch (...) {
87389       {
87390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87391       };
87392     }
87393   }
87394
87395   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87396   return jresult;
87397 }
87398
87399
87400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87401   void * jresult ;
87402   Dali::Toolkit::Slider *result = 0 ;
87403
87404   {
87405     try {
87406       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87407     } catch (std::out_of_range& e) {
87408       {
87409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87410       };
87411     } catch (std::exception& e) {
87412       {
87413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87414       };
87415     } catch (Dali::DaliException e) {
87416       {
87417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87418       };
87419     } catch (...) {
87420       {
87421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87422       };
87423     }
87424   }
87425
87426   jresult = (void *)result;
87427   return jresult;
87428 }
87429
87430
87431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87432   void * jresult ;
87433   Dali::Toolkit::Slider *arg1 = 0 ;
87434   Dali::Toolkit::Slider *result = 0 ;
87435
87436   arg1 = (Dali::Toolkit::Slider *)jarg1;
87437   if (!arg1) {
87438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87439     return 0;
87440   }
87441   {
87442     try {
87443       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87444     } catch (std::out_of_range& e) {
87445       {
87446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87447       };
87448     } catch (std::exception& e) {
87449       {
87450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87451       };
87452     } catch (Dali::DaliException e) {
87453       {
87454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87455       };
87456     } catch (...) {
87457       {
87458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87459       };
87460     }
87461   }
87462
87463   jresult = (void *)result;
87464   return jresult;
87465 }
87466
87467
87468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87469   void * jresult ;
87470   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87471   Dali::Toolkit::Slider *arg2 = 0 ;
87472   Dali::Toolkit::Slider *result = 0 ;
87473
87474   arg1 = (Dali::Toolkit::Slider *)jarg1;
87475   arg2 = (Dali::Toolkit::Slider *)jarg2;
87476   if (!arg2) {
87477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87478     return 0;
87479   }
87480   {
87481     try {
87482       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87483     } catch (std::out_of_range& e) {
87484       {
87485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87486       };
87487     } catch (std::exception& e) {
87488       {
87489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87490       };
87491     } catch (Dali::DaliException e) {
87492       {
87493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87494       };
87495     } catch (...) {
87496       {
87497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87498       };
87499     }
87500   }
87501
87502   jresult = (void *)result;
87503   return jresult;
87504 }
87505
87506
87507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87508   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87509
87510   arg1 = (Dali::Toolkit::Slider *)jarg1;
87511   {
87512     try {
87513       delete arg1;
87514     } catch (std::out_of_range& e) {
87515       {
87516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87517       };
87518     } catch (std::exception& e) {
87519       {
87520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87521       };
87522     } catch (Dali::DaliException e) {
87523       {
87524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87525       };
87526     } catch (...) {
87527       {
87528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87529       };
87530     }
87531   }
87532
87533 }
87534
87535
87536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87537   void * jresult ;
87538   Dali::BaseHandle arg1 ;
87539   Dali::BaseHandle *argp1 ;
87540   Dali::Toolkit::Slider result;
87541
87542   argp1 = (Dali::BaseHandle *)jarg1;
87543   if (!argp1) {
87544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87545     return 0;
87546   }
87547   arg1 = *argp1;
87548   {
87549     try {
87550       result = Dali::Toolkit::Slider::DownCast(arg1);
87551     } catch (std::out_of_range& e) {
87552       {
87553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87554       };
87555     } catch (std::exception& e) {
87556       {
87557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87558       };
87559     } catch (Dali::DaliException e) {
87560       {
87561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87562       };
87563     } catch (...) {
87564       {
87565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87566       };
87567     }
87568   }
87569
87570   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87571   return jresult;
87572 }
87573
87574
87575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87576   void * jresult ;
87577   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87578   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87579
87580   arg1 = (Dali::Toolkit::Slider *)jarg1;
87581   {
87582     try {
87583       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87584     } catch (std::out_of_range& e) {
87585       {
87586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87587       };
87588     } catch (std::exception& e) {
87589       {
87590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87591       };
87592     } catch (Dali::DaliException e) {
87593       {
87594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87595       };
87596     } catch (...) {
87597       {
87598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87599       };
87600     }
87601   }
87602
87603   jresult = (void *)result;
87604   return jresult;
87605 }
87606
87607
87608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87609   void * jresult ;
87610   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87611   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87612
87613   arg1 = (Dali::Toolkit::Slider *)jarg1;
87614   {
87615     try {
87616       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87617     } catch (std::out_of_range& e) {
87618       {
87619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87620       };
87621     } catch (std::exception& e) {
87622       {
87623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87624       };
87625     } catch (Dali::DaliException e) {
87626       {
87627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87628       };
87629     } catch (...) {
87630       {
87631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87632       };
87633     }
87634   }
87635
87636   jresult = (void *)result;
87637   return jresult;
87638 }
87639
87640
87641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87642   void * jresult ;
87643   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87644   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87645
87646   arg1 = (Dali::Toolkit::Slider *)jarg1;
87647   {
87648     try {
87649       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87650     } catch (std::out_of_range& e) {
87651       {
87652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87653       };
87654     } catch (std::exception& e) {
87655       {
87656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87657       };
87658     } catch (Dali::DaliException e) {
87659       {
87660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87661       };
87662     } catch (...) {
87663       {
87664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87665       };
87666     }
87667   }
87668
87669   jresult = (void *)result;
87670   return jresult;
87671 }
87672
87673
87674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87675   int jresult ;
87676   int result;
87677
87678   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87679   jresult = (int)result;
87680   return jresult;
87681 }
87682
87683
87684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87685   int jresult ;
87686   int result;
87687
87688   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87689   jresult = (int)result;
87690   return jresult;
87691 }
87692
87693
87694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87695   int jresult ;
87696   int result;
87697
87698   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87699   jresult = (int)result;
87700   return jresult;
87701 }
87702
87703
87704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87705   int jresult ;
87706   int result;
87707
87708   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87709   jresult = (int)result;
87710   return jresult;
87711 }
87712
87713
87714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87715   int result;
87716
87717   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87718
87719   return result;
87720 }
87721
87722
87723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87724   void * jresult ;
87725   Dali::Toolkit::VideoView::Property *result = 0 ;
87726
87727   {
87728     try {
87729       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87730     } catch (std::out_of_range& e) {
87731       {
87732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87733       };
87734     } catch (std::exception& e) {
87735       {
87736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87737       };
87738     } catch (Dali::DaliException e) {
87739       {
87740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87741       };
87742     } catch (...) {
87743       {
87744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87745       };
87746     }
87747   }
87748
87749   jresult = (void *)result;
87750   return jresult;
87751 }
87752
87753
87754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87755   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87756
87757   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87758   {
87759     try {
87760       delete arg1;
87761     } catch (std::out_of_range& e) {
87762       {
87763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87764       };
87765     } catch (std::exception& e) {
87766       {
87767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87768       };
87769     } catch (Dali::DaliException e) {
87770       {
87771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87772       };
87773     } catch (...) {
87774       {
87775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87776       };
87777     }
87778   }
87779
87780 }
87781
87782
87783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87784   void * jresult ;
87785   Dali::Toolkit::VideoView result;
87786
87787   {
87788     try {
87789       result = Dali::Toolkit::VideoView::New();
87790     } catch (std::out_of_range& e) {
87791       {
87792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87793       };
87794     } catch (std::exception& e) {
87795       {
87796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87797       };
87798     } catch (Dali::DaliException e) {
87799       {
87800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87801       };
87802     } catch (...) {
87803       {
87804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87805       };
87806     }
87807   }
87808
87809   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87810   return jresult;
87811 }
87812
87813
87814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87815   void * jresult ;
87816   std::string *arg1 = 0 ;
87817   Dali::Toolkit::VideoView result;
87818
87819   if (!jarg1) {
87820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87821     return 0;
87822   }
87823   std::string arg1_str(jarg1);
87824   arg1 = &arg1_str;
87825   {
87826     try {
87827       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87828     } catch (std::out_of_range& e) {
87829       {
87830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87831       };
87832     } catch (std::exception& e) {
87833       {
87834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87835       };
87836     } catch (Dali::DaliException e) {
87837       {
87838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87839       };
87840     } catch (...) {
87841       {
87842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87843       };
87844     }
87845   }
87846
87847   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87848
87849   //argout typemap for const std::string&
87850
87851   return jresult;
87852 }
87853
87854
87855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87856   void * jresult ;
87857   Dali::Toolkit::VideoView *result = 0 ;
87858
87859   {
87860     try {
87861       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87862     } catch (std::out_of_range& e) {
87863       {
87864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87865       };
87866     } catch (std::exception& e) {
87867       {
87868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87869       };
87870     } catch (Dali::DaliException e) {
87871       {
87872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87873       };
87874     } catch (...) {
87875       {
87876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87877       };
87878     }
87879   }
87880
87881   jresult = (void *)result;
87882   return jresult;
87883 }
87884
87885
87886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87887   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87888
87889   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87890   {
87891     try {
87892       delete arg1;
87893     } catch (std::out_of_range& e) {
87894       {
87895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87896       };
87897     } catch (std::exception& e) {
87898       {
87899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87900       };
87901     } catch (Dali::DaliException e) {
87902       {
87903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87904       };
87905     } catch (...) {
87906       {
87907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87908       };
87909     }
87910   }
87911
87912 }
87913
87914
87915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87916   void * jresult ;
87917   Dali::Toolkit::VideoView *arg1 = 0 ;
87918   Dali::Toolkit::VideoView *result = 0 ;
87919
87920   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87921   if (!arg1) {
87922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87923     return 0;
87924   }
87925   {
87926     try {
87927       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87928     } catch (std::out_of_range& e) {
87929       {
87930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87931       };
87932     } catch (std::exception& e) {
87933       {
87934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87935       };
87936     } catch (Dali::DaliException e) {
87937       {
87938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87939       };
87940     } catch (...) {
87941       {
87942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87943       };
87944     }
87945   }
87946
87947   jresult = (void *)result;
87948   return jresult;
87949 }
87950
87951
87952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87953   void * jresult ;
87954   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87955   Dali::Toolkit::VideoView *arg2 = 0 ;
87956   Dali::Toolkit::VideoView *result = 0 ;
87957
87958   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87959   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87960   if (!arg2) {
87961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87962     return 0;
87963   }
87964   {
87965     try {
87966       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87967     } catch (std::out_of_range& e) {
87968       {
87969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87970       };
87971     } catch (std::exception& e) {
87972       {
87973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87974       };
87975     } catch (Dali::DaliException e) {
87976       {
87977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87978       };
87979     } catch (...) {
87980       {
87981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87982       };
87983     }
87984   }
87985
87986   jresult = (void *)result;
87987   return jresult;
87988 }
87989
87990
87991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87992   void * jresult ;
87993   Dali::BaseHandle arg1 ;
87994   Dali::BaseHandle *argp1 ;
87995   Dali::Toolkit::VideoView result;
87996
87997   argp1 = (Dali::BaseHandle *)jarg1;
87998   if (!argp1) {
87999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88000     return 0;
88001   }
88002   arg1 = *argp1;
88003   {
88004     try {
88005       result = Dali::Toolkit::VideoView::DownCast(arg1);
88006     } catch (std::out_of_range& e) {
88007       {
88008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88009       };
88010     } catch (std::exception& e) {
88011       {
88012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88013       };
88014     } catch (Dali::DaliException e) {
88015       {
88016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88017       };
88018     } catch (...) {
88019       {
88020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88021       };
88022     }
88023   }
88024
88025   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
88026   return jresult;
88027 }
88028
88029
88030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
88031   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88032
88033   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88034   {
88035     try {
88036       (arg1)->Play();
88037     } catch (std::out_of_range& e) {
88038       {
88039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88040       };
88041     } catch (std::exception& e) {
88042       {
88043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88044       };
88045     } catch (Dali::DaliException e) {
88046       {
88047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88048       };
88049     } catch (...) {
88050       {
88051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88052       };
88053     }
88054   }
88055
88056 }
88057
88058
88059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
88060   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88061
88062   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88063   {
88064     try {
88065       (arg1)->Pause();
88066     } catch (std::out_of_range& e) {
88067       {
88068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88069       };
88070     } catch (std::exception& e) {
88071       {
88072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88073       };
88074     } catch (Dali::DaliException e) {
88075       {
88076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88077       };
88078     } catch (...) {
88079       {
88080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88081       };
88082     }
88083   }
88084
88085 }
88086
88087
88088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
88089   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88090
88091   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88092   {
88093     try {
88094       (arg1)->Stop();
88095     } catch (std::out_of_range& e) {
88096       {
88097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88098       };
88099     } catch (std::exception& e) {
88100       {
88101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88102       };
88103     } catch (Dali::DaliException e) {
88104       {
88105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88106       };
88107     } catch (...) {
88108       {
88109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88110       };
88111     }
88112   }
88113
88114 }
88115
88116
88117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
88118   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88119   int arg2 ;
88120
88121   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88122   arg2 = (int)jarg2;
88123   {
88124     try {
88125       (arg1)->Forward(arg2);
88126     } catch (std::out_of_range& e) {
88127       {
88128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88129       };
88130     } catch (std::exception& e) {
88131       {
88132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88133       };
88134     } catch (Dali::DaliException e) {
88135       {
88136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88137       };
88138     } catch (...) {
88139       {
88140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88141       };
88142     }
88143   }
88144
88145 }
88146
88147
88148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88149   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88150   int arg2 ;
88151
88152   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88153   arg2 = (int)jarg2;
88154   {
88155     try {
88156       (arg1)->Backward(arg2);
88157     } catch (std::out_of_range& e) {
88158       {
88159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88160       };
88161     } catch (std::exception& e) {
88162       {
88163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88164       };
88165     } catch (Dali::DaliException e) {
88166       {
88167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88168       };
88169     } catch (...) {
88170       {
88171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88172       };
88173     }
88174   }
88175
88176 }
88177
88178
88179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88180   void * jresult ;
88181   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88182   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88183
88184   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88185   {
88186     try {
88187       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88188     } catch (std::out_of_range& e) {
88189       {
88190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88191       };
88192     } catch (std::exception& e) {
88193       {
88194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88195       };
88196     } catch (Dali::DaliException e) {
88197       {
88198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88199       };
88200     } catch (...) {
88201       {
88202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88203       };
88204     }
88205   }
88206
88207   jresult = (void *)result;
88208   return jresult;
88209 }
88210
88211
88212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88213   int jresult ;
88214   int result;
88215
88216   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88217   jresult = (int)result;
88218   return jresult;
88219 }
88220
88221
88222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88223   int jresult ;
88224   int result;
88225
88226   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88227   jresult = (int)result;
88228   return jresult;
88229 }
88230
88231
88232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88233   int jresult ;
88234   int result;
88235
88236   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88237   jresult = (int)result;
88238   return jresult;
88239 }
88240
88241
88242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88243   int jresult ;
88244   int result;
88245
88246   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88247   jresult = (int)result;
88248   return jresult;
88249 }
88250
88251
88252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88253   int jresult ;
88254   int result;
88255
88256   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88257   jresult = (int)result;
88258   return jresult;
88259 }
88260
88261
88262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88263   int jresult ;
88264   int result;
88265
88266   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88267   jresult = (int)result;
88268   return jresult;
88269 }
88270
88271
88272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88273   int jresult ;
88274   int result;
88275
88276   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88277   jresult = (int)result;
88278   return jresult;
88279 }
88280
88281
88282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88283   int jresult ;
88284   int result;
88285
88286   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88287   jresult = (int)result;
88288   return jresult;
88289 }
88290
88291
88292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88293   int jresult ;
88294   int result;
88295
88296   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88297   jresult = (int)result;
88298   return jresult;
88299 }
88300
88301
88302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88303   int jresult ;
88304   int result;
88305
88306   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88307   jresult = (int)result;
88308   return jresult;
88309 }
88310
88311
88312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88313   int jresult ;
88314   int result;
88315
88316   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88317   jresult = (int)result;
88318   return jresult;
88319 }
88320
88321
88322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88323   int jresult ;
88324   int result;
88325
88326   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88327   jresult = (int)result;
88328   return jresult;
88329 }
88330
88331
88332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88333   int jresult ;
88334   int result;
88335
88336   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88337   jresult = (int)result;
88338   return jresult;
88339 }
88340
88341
88342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88343   int jresult ;
88344   int result;
88345
88346   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88347   jresult = (int)result;
88348   return jresult;
88349 }
88350
88351
88352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88353   int jresult ;
88354   int result;
88355
88356   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88357   jresult = (int)result;
88358   return jresult;
88359 }
88360
88361
88362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88363   int jresult ;
88364   int result;
88365
88366   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88367   jresult = (int)result;
88368   return jresult;
88369 }
88370
88371
88372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88373   int jresult ;
88374   int result;
88375
88376   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88377   jresult = (int)result;
88378   return jresult;
88379 }
88380
88381
88382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88383   int jresult ;
88384   int result;
88385
88386   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88387   jresult = (int)result;
88388   return jresult;
88389 }
88390
88391
88392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88393   int jresult ;
88394   int result;
88395
88396   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88397   jresult = (int)result;
88398   return jresult;
88399 }
88400
88401
88402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88403   int jresult ;
88404   int result;
88405
88406   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88407   jresult = (int)result;
88408   return jresult;
88409 }
88410
88411
88412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88413   int jresult ;
88414   int result;
88415
88416   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88417   jresult = (int)result;
88418   return jresult;
88419 }
88420
88421
88422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88423   void * jresult ;
88424   Dali::Toolkit::Popup::Property *result = 0 ;
88425
88426   {
88427     try {
88428       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88429     } catch (std::out_of_range& e) {
88430       {
88431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88432       };
88433     } catch (std::exception& e) {
88434       {
88435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88436       };
88437     } catch (Dali::DaliException e) {
88438       {
88439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88440       };
88441     } catch (...) {
88442       {
88443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88444       };
88445     }
88446   }
88447
88448   jresult = (void *)result;
88449   return jresult;
88450 }
88451
88452
88453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88454   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88455
88456   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88457   {
88458     try {
88459       delete arg1;
88460     } catch (std::out_of_range& e) {
88461       {
88462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88463       };
88464     } catch (std::exception& e) {
88465       {
88466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88467       };
88468     } catch (Dali::DaliException e) {
88469       {
88470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88471       };
88472     } catch (...) {
88473       {
88474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88475       };
88476     }
88477   }
88478
88479 }
88480
88481
88482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88483   void * jresult ;
88484   Dali::Toolkit::Popup *result = 0 ;
88485
88486   {
88487     try {
88488       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88489     } catch (std::out_of_range& e) {
88490       {
88491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88492       };
88493     } catch (std::exception& e) {
88494       {
88495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88496       };
88497     } catch (Dali::DaliException e) {
88498       {
88499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88500       };
88501     } catch (...) {
88502       {
88503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88504       };
88505     }
88506   }
88507
88508   jresult = (void *)result;
88509   return jresult;
88510 }
88511
88512
88513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88514   void * jresult ;
88515   Dali::Toolkit::Popup result;
88516
88517   {
88518     try {
88519       result = Dali::Toolkit::Popup::New();
88520     } catch (std::out_of_range& e) {
88521       {
88522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88523       };
88524     } catch (std::exception& e) {
88525       {
88526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88527       };
88528     } catch (Dali::DaliException e) {
88529       {
88530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88531       };
88532     } catch (...) {
88533       {
88534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88535       };
88536     }
88537   }
88538
88539   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88540   return jresult;
88541 }
88542
88543
88544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88545   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88546
88547   arg1 = (Dali::Toolkit::Popup *)jarg1;
88548   {
88549     try {
88550       delete arg1;
88551     } catch (std::out_of_range& e) {
88552       {
88553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88554       };
88555     } catch (std::exception& e) {
88556       {
88557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88558       };
88559     } catch (Dali::DaliException e) {
88560       {
88561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88562       };
88563     } catch (...) {
88564       {
88565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88566       };
88567     }
88568   }
88569
88570 }
88571
88572
88573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88574   void * jresult ;
88575   Dali::Toolkit::Popup *arg1 = 0 ;
88576   Dali::Toolkit::Popup *result = 0 ;
88577
88578   arg1 = (Dali::Toolkit::Popup *)jarg1;
88579   if (!arg1) {
88580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88581     return 0;
88582   }
88583   {
88584     try {
88585       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88586     } catch (std::out_of_range& e) {
88587       {
88588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88589       };
88590     } catch (std::exception& e) {
88591       {
88592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88593       };
88594     } catch (Dali::DaliException e) {
88595       {
88596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88597       };
88598     } catch (...) {
88599       {
88600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88601       };
88602     }
88603   }
88604
88605   jresult = (void *)result;
88606   return jresult;
88607 }
88608
88609
88610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88611   void * jresult ;
88612   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88613   Dali::Toolkit::Popup *arg2 = 0 ;
88614   Dali::Toolkit::Popup *result = 0 ;
88615
88616   arg1 = (Dali::Toolkit::Popup *)jarg1;
88617   arg2 = (Dali::Toolkit::Popup *)jarg2;
88618   if (!arg2) {
88619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88620     return 0;
88621   }
88622   {
88623     try {
88624       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88625     } catch (std::out_of_range& e) {
88626       {
88627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88628       };
88629     } catch (std::exception& e) {
88630       {
88631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88632       };
88633     } catch (Dali::DaliException e) {
88634       {
88635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88636       };
88637     } catch (...) {
88638       {
88639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88640       };
88641     }
88642   }
88643
88644   jresult = (void *)result;
88645   return jresult;
88646 }
88647
88648
88649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88650   void * jresult ;
88651   Dali::BaseHandle arg1 ;
88652   Dali::BaseHandle *argp1 ;
88653   Dali::Toolkit::Popup result;
88654
88655   argp1 = (Dali::BaseHandle *)jarg1;
88656   if (!argp1) {
88657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88658     return 0;
88659   }
88660   arg1 = *argp1;
88661   {
88662     try {
88663       result = Dali::Toolkit::Popup::DownCast(arg1);
88664     } catch (std::out_of_range& e) {
88665       {
88666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88667       };
88668     } catch (std::exception& e) {
88669       {
88670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88671       };
88672     } catch (Dali::DaliException e) {
88673       {
88674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88675       };
88676     } catch (...) {
88677       {
88678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88679       };
88680     }
88681   }
88682
88683   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88684   return jresult;
88685 }
88686
88687
88688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88689   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88690   Dali::Actor arg2 ;
88691   Dali::Actor *argp2 ;
88692
88693   arg1 = (Dali::Toolkit::Popup *)jarg1;
88694   argp2 = (Dali::Actor *)jarg2;
88695   if (!argp2) {
88696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88697     return ;
88698   }
88699   arg2 = *argp2;
88700   {
88701     try {
88702       (arg1)->SetTitle(arg2);
88703     } catch (std::out_of_range& e) {
88704       {
88705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88706       };
88707     } catch (std::exception& e) {
88708       {
88709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88710       };
88711     } catch (Dali::DaliException e) {
88712       {
88713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88714       };
88715     } catch (...) {
88716       {
88717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88718       };
88719     }
88720   }
88721
88722 }
88723
88724
88725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88726   void * jresult ;
88727   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88728   Dali::Actor result;
88729
88730   arg1 = (Dali::Toolkit::Popup *)jarg1;
88731   {
88732     try {
88733       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88734     } catch (std::out_of_range& e) {
88735       {
88736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88737       };
88738     } catch (std::exception& e) {
88739       {
88740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88741       };
88742     } catch (Dali::DaliException e) {
88743       {
88744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88745       };
88746     } catch (...) {
88747       {
88748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88749       };
88750     }
88751   }
88752
88753   jresult = new Dali::Actor((const Dali::Actor &)result);
88754   return jresult;
88755 }
88756
88757
88758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88759   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88760   Dali::Actor arg2 ;
88761   Dali::Actor *argp2 ;
88762
88763   arg1 = (Dali::Toolkit::Popup *)jarg1;
88764   argp2 = (Dali::Actor *)jarg2;
88765   if (!argp2) {
88766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88767     return ;
88768   }
88769   arg2 = *argp2;
88770   {
88771     try {
88772       (arg1)->SetContent(arg2);
88773     } catch (std::out_of_range& e) {
88774       {
88775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88776       };
88777     } catch (std::exception& e) {
88778       {
88779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88780       };
88781     } catch (Dali::DaliException e) {
88782       {
88783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88784       };
88785     } catch (...) {
88786       {
88787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88788       };
88789     }
88790   }
88791
88792 }
88793
88794
88795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88796   void * jresult ;
88797   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88798   Dali::Actor result;
88799
88800   arg1 = (Dali::Toolkit::Popup *)jarg1;
88801   {
88802     try {
88803       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88804     } catch (std::out_of_range& e) {
88805       {
88806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88807       };
88808     } catch (std::exception& e) {
88809       {
88810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88811       };
88812     } catch (Dali::DaliException e) {
88813       {
88814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88815       };
88816     } catch (...) {
88817       {
88818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88819       };
88820     }
88821   }
88822
88823   jresult = new Dali::Actor((const Dali::Actor &)result);
88824   return jresult;
88825 }
88826
88827
88828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88829   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88830   Dali::Actor arg2 ;
88831   Dali::Actor *argp2 ;
88832
88833   arg1 = (Dali::Toolkit::Popup *)jarg1;
88834   argp2 = (Dali::Actor *)jarg2;
88835   if (!argp2) {
88836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88837     return ;
88838   }
88839   arg2 = *argp2;
88840   {
88841     try {
88842       (arg1)->SetFooter(arg2);
88843     } catch (std::out_of_range& e) {
88844       {
88845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88846       };
88847     } catch (std::exception& e) {
88848       {
88849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88850       };
88851     } catch (Dali::DaliException e) {
88852       {
88853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88854       };
88855     } catch (...) {
88856       {
88857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88858       };
88859     }
88860   }
88861
88862 }
88863
88864
88865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88866   void * jresult ;
88867   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88868   Dali::Actor result;
88869
88870   arg1 = (Dali::Toolkit::Popup *)jarg1;
88871   {
88872     try {
88873       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88874     } catch (std::out_of_range& e) {
88875       {
88876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88877       };
88878     } catch (std::exception& e) {
88879       {
88880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88881       };
88882     } catch (Dali::DaliException e) {
88883       {
88884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88885       };
88886     } catch (...) {
88887       {
88888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88889       };
88890     }
88891   }
88892
88893   jresult = new Dali::Actor((const Dali::Actor &)result);
88894   return jresult;
88895 }
88896
88897
88898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88899   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88900   Dali::Toolkit::Popup::DisplayState arg2 ;
88901
88902   arg1 = (Dali::Toolkit::Popup *)jarg1;
88903   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88904   {
88905     try {
88906       (arg1)->SetDisplayState(arg2);
88907     } catch (std::out_of_range& e) {
88908       {
88909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88910       };
88911     } catch (std::exception& e) {
88912       {
88913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88914       };
88915     } catch (Dali::DaliException e) {
88916       {
88917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88918       };
88919     } catch (...) {
88920       {
88921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88922       };
88923     }
88924   }
88925
88926 }
88927
88928
88929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88930   int jresult ;
88931   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88932   Dali::Toolkit::Popup::DisplayState result;
88933
88934   arg1 = (Dali::Toolkit::Popup *)jarg1;
88935   {
88936     try {
88937       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88938     } catch (std::out_of_range& e) {
88939       {
88940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88941       };
88942     } catch (std::exception& e) {
88943       {
88944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88945       };
88946     } catch (Dali::DaliException e) {
88947       {
88948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88949       };
88950     } catch (...) {
88951       {
88952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88953       };
88954     }
88955   }
88956
88957   jresult = (int)result;
88958   return jresult;
88959 }
88960
88961
88962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88963   void * jresult ;
88964   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88965   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88966
88967   arg1 = (Dali::Toolkit::Popup *)jarg1;
88968   {
88969     try {
88970       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88971     } catch (std::out_of_range& e) {
88972       {
88973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88974       };
88975     } catch (std::exception& e) {
88976       {
88977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88978       };
88979     } catch (Dali::DaliException e) {
88980       {
88981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88982       };
88983     } catch (...) {
88984       {
88985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88986       };
88987     }
88988   }
88989
88990   jresult = (void *)result;
88991   return jresult;
88992 }
88993
88994
88995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88996   void * jresult ;
88997   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88998   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88999
89000   arg1 = (Dali::Toolkit::Popup *)jarg1;
89001   {
89002     try {
89003       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
89004     } catch (std::out_of_range& e) {
89005       {
89006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89007       };
89008     } catch (std::exception& e) {
89009       {
89010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89011       };
89012     } catch (Dali::DaliException e) {
89013       {
89014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89015       };
89016     } catch (...) {
89017       {
89018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89019       };
89020     }
89021   }
89022
89023   jresult = (void *)result;
89024   return jresult;
89025 }
89026
89027
89028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
89029   void * jresult ;
89030   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89031   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89032
89033   arg1 = (Dali::Toolkit::Popup *)jarg1;
89034   {
89035     try {
89036       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
89037     } catch (std::out_of_range& e) {
89038       {
89039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89040       };
89041     } catch (std::exception& e) {
89042       {
89043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89044       };
89045     } catch (Dali::DaliException e) {
89046       {
89047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89048       };
89049     } catch (...) {
89050       {
89051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89052       };
89053     }
89054   }
89055
89056   jresult = (void *)result;
89057   return jresult;
89058 }
89059
89060
89061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
89062   void * jresult ;
89063   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89064   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89065
89066   arg1 = (Dali::Toolkit::Popup *)jarg1;
89067   {
89068     try {
89069       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
89070     } catch (std::out_of_range& e) {
89071       {
89072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89073       };
89074     } catch (std::exception& e) {
89075       {
89076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89077       };
89078     } catch (Dali::DaliException e) {
89079       {
89080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89081       };
89082     } catch (...) {
89083       {
89084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89085       };
89086     }
89087   }
89088
89089   jresult = (void *)result;
89090   return jresult;
89091 }
89092
89093
89094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
89095   void * jresult ;
89096   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89097   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89098
89099   arg1 = (Dali::Toolkit::Popup *)jarg1;
89100   {
89101     try {
89102       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
89103     } catch (std::out_of_range& e) {
89104       {
89105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89106       };
89107     } catch (std::exception& e) {
89108       {
89109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89110       };
89111     } catch (Dali::DaliException e) {
89112       {
89113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89114       };
89115     } catch (...) {
89116       {
89117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89118       };
89119     }
89120   }
89121
89122   jresult = (void *)result;
89123   return jresult;
89124 }
89125
89126
89127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
89128   int jresult ;
89129   int result;
89130
89131   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
89132   jresult = (int)result;
89133   return jresult;
89134 }
89135
89136
89137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
89138   int jresult ;
89139   int result;
89140
89141   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
89142   jresult = (int)result;
89143   return jresult;
89144 }
89145
89146
89147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89148   int jresult ;
89149   int result;
89150
89151   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89152   jresult = (int)result;
89153   return jresult;
89154 }
89155
89156
89157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89158   int jresult ;
89159   int result;
89160
89161   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89162   jresult = (int)result;
89163   return jresult;
89164 }
89165
89166
89167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89168   int jresult ;
89169   int result;
89170
89171   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89172   jresult = (int)result;
89173   return jresult;
89174 }
89175
89176
89177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89178   int jresult ;
89179   int result;
89180
89181   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89182   jresult = (int)result;
89183   return jresult;
89184 }
89185
89186
89187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89188   int jresult ;
89189   int result;
89190
89191   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89192   jresult = (int)result;
89193   return jresult;
89194 }
89195
89196
89197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89198   int jresult ;
89199   int result;
89200
89201   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89202   jresult = (int)result;
89203   return jresult;
89204 }
89205
89206
89207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89208   int jresult ;
89209   int result;
89210
89211   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89212   jresult = (int)result;
89213   return jresult;
89214 }
89215
89216
89217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89218   void * jresult ;
89219   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89220
89221   {
89222     try {
89223       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89224     } catch (std::out_of_range& e) {
89225       {
89226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89227       };
89228     } catch (std::exception& e) {
89229       {
89230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89231       };
89232     } catch (Dali::DaliException e) {
89233       {
89234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89235       };
89236     } catch (...) {
89237       {
89238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89239       };
89240     }
89241   }
89242
89243   jresult = (void *)result;
89244   return jresult;
89245 }
89246
89247
89248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89249   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89250
89251   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89252   {
89253     try {
89254       delete arg1;
89255     } catch (std::out_of_range& e) {
89256       {
89257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89258       };
89259     } catch (std::exception& e) {
89260       {
89261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89262       };
89263     } catch (Dali::DaliException e) {
89264       {
89265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89266       };
89267     } catch (...) {
89268       {
89269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89270       };
89271     }
89272   }
89273
89274 }
89275
89276
89277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89278   void * jresult ;
89279   Dali::Toolkit::ProgressBar result;
89280
89281   {
89282     try {
89283       result = Dali::Toolkit::ProgressBar::New();
89284     } catch (std::out_of_range& e) {
89285       {
89286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89287       };
89288     } catch (std::exception& e) {
89289       {
89290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89291       };
89292     } catch (Dali::DaliException e) {
89293       {
89294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89295       };
89296     } catch (...) {
89297       {
89298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89299       };
89300     }
89301   }
89302
89303   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89304   return jresult;
89305 }
89306
89307
89308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89309   void * jresult ;
89310   Dali::Toolkit::ProgressBar *result = 0 ;
89311
89312   {
89313     try {
89314       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89315     } catch (std::out_of_range& e) {
89316       {
89317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89318       };
89319     } catch (std::exception& e) {
89320       {
89321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89322       };
89323     } catch (Dali::DaliException e) {
89324       {
89325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89326       };
89327     } catch (...) {
89328       {
89329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89330       };
89331     }
89332   }
89333
89334   jresult = (void *)result;
89335   return jresult;
89336 }
89337
89338
89339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89340   void * jresult ;
89341   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89342   Dali::Toolkit::ProgressBar *result = 0 ;
89343
89344   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89345   if (!arg1) {
89346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89347     return 0;
89348   }
89349   {
89350     try {
89351       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89352     } catch (std::out_of_range& e) {
89353       {
89354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89355       };
89356     } catch (std::exception& e) {
89357       {
89358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89359       };
89360     } catch (Dali::DaliException e) {
89361       {
89362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89363       };
89364     } catch (...) {
89365       {
89366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89367       };
89368     }
89369   }
89370
89371   jresult = (void *)result;
89372   return jresult;
89373 }
89374
89375
89376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89377   void * jresult ;
89378   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89379   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89380   Dali::Toolkit::ProgressBar *result = 0 ;
89381
89382   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89383   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89384   if (!arg2) {
89385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89386     return 0;
89387   }
89388   {
89389     try {
89390       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89391     } catch (std::out_of_range& e) {
89392       {
89393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89394       };
89395     } catch (std::exception& e) {
89396       {
89397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89398       };
89399     } catch (Dali::DaliException e) {
89400       {
89401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89402       };
89403     } catch (...) {
89404       {
89405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89406       };
89407     }
89408   }
89409
89410   jresult = (void *)result;
89411   return jresult;
89412 }
89413
89414
89415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89416   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89417
89418   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89419   {
89420     try {
89421       delete arg1;
89422     } catch (std::out_of_range& e) {
89423       {
89424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89425       };
89426     } catch (std::exception& e) {
89427       {
89428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89429       };
89430     } catch (Dali::DaliException e) {
89431       {
89432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89433       };
89434     } catch (...) {
89435       {
89436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89437       };
89438     }
89439   }
89440
89441 }
89442
89443
89444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89445   void * jresult ;
89446   Dali::BaseHandle arg1 ;
89447   Dali::BaseHandle *argp1 ;
89448   Dali::Toolkit::ProgressBar result;
89449
89450   argp1 = (Dali::BaseHandle *)jarg1;
89451   if (!argp1) {
89452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89453     return 0;
89454   }
89455   arg1 = *argp1;
89456   {
89457     try {
89458       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89459     } catch (std::out_of_range& e) {
89460       {
89461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89462       };
89463     } catch (std::exception& e) {
89464       {
89465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89466       };
89467     } catch (Dali::DaliException e) {
89468       {
89469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89470       };
89471     } catch (...) {
89472       {
89473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89474       };
89475     }
89476   }
89477
89478   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89479   return jresult;
89480 }
89481
89482
89483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89484   void * jresult ;
89485   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89486   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89487
89488   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89489   {
89490     try {
89491       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89492     } catch (std::out_of_range& e) {
89493       {
89494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89495       };
89496     } catch (std::exception& e) {
89497       {
89498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89499       };
89500     } catch (Dali::DaliException e) {
89501       {
89502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89503       };
89504     } catch (...) {
89505       {
89506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89507       };
89508     }
89509   }
89510
89511   jresult = (void *)result;
89512   return jresult;
89513 }
89514
89515
89516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89517   void * jresult ;
89518   Dali::Toolkit::GaussianBlurView *result = 0 ;
89519
89520   {
89521     try {
89522       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89523     } catch (std::out_of_range& e) {
89524       {
89525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89526       };
89527     } catch (std::exception& e) {
89528       {
89529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89530       };
89531     } catch (Dali::DaliException e) {
89532       {
89533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89534       };
89535     } catch (...) {
89536       {
89537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89538       };
89539     }
89540   }
89541
89542   jresult = (void *)result;
89543   return jresult;
89544 }
89545
89546
89547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89548   void * jresult ;
89549   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89550   Dali::Toolkit::GaussianBlurView *result = 0 ;
89551
89552   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89553   if (!arg1) {
89554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89555     return 0;
89556   }
89557   {
89558     try {
89559       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89560     } catch (std::out_of_range& e) {
89561       {
89562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89563       };
89564     } catch (std::exception& e) {
89565       {
89566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89567       };
89568     } catch (Dali::DaliException e) {
89569       {
89570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89571       };
89572     } catch (...) {
89573       {
89574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89575       };
89576     }
89577   }
89578
89579   jresult = (void *)result;
89580   return jresult;
89581 }
89582
89583
89584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89585   void * jresult ;
89586   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89587   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89588   Dali::Toolkit::GaussianBlurView *result = 0 ;
89589
89590   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89591   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89592   if (!arg2) {
89593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89594     return 0;
89595   }
89596   {
89597     try {
89598       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89599     } catch (std::out_of_range& e) {
89600       {
89601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89602       };
89603     } catch (std::exception& e) {
89604       {
89605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89606       };
89607     } catch (Dali::DaliException e) {
89608       {
89609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89610       };
89611     } catch (...) {
89612       {
89613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89614       };
89615     }
89616   }
89617
89618   jresult = (void *)result;
89619   return jresult;
89620 }
89621
89622
89623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89624   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89625
89626   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89627   {
89628     try {
89629       delete arg1;
89630     } catch (std::out_of_range& e) {
89631       {
89632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89633       };
89634     } catch (std::exception& e) {
89635       {
89636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89637       };
89638     } catch (Dali::DaliException e) {
89639       {
89640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89641       };
89642     } catch (...) {
89643       {
89644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89645       };
89646     }
89647   }
89648
89649 }
89650
89651
89652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89653   void * jresult ;
89654   Dali::BaseHandle arg1 ;
89655   Dali::BaseHandle *argp1 ;
89656   Dali::Toolkit::GaussianBlurView result;
89657
89658   argp1 = (Dali::BaseHandle *)jarg1;
89659   if (!argp1) {
89660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89661     return 0;
89662   }
89663   arg1 = *argp1;
89664   {
89665     try {
89666       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89667     } catch (std::out_of_range& e) {
89668       {
89669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89670       };
89671     } catch (std::exception& e) {
89672       {
89673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89674       };
89675     } catch (Dali::DaliException e) {
89676       {
89677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89678       };
89679     } catch (...) {
89680       {
89681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89682       };
89683     }
89684   }
89685
89686   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89687   return jresult;
89688 }
89689
89690
89691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89692   void * jresult ;
89693   Dali::Toolkit::GaussianBlurView result;
89694
89695   {
89696     try {
89697       result = Dali::Toolkit::GaussianBlurView::New();
89698     } catch (std::out_of_range& e) {
89699       {
89700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89701       };
89702     } catch (std::exception& e) {
89703       {
89704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89705       };
89706     } catch (Dali::DaliException e) {
89707       {
89708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89709       };
89710     } catch (...) {
89711       {
89712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89713       };
89714     }
89715   }
89716
89717   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89718   return jresult;
89719 }
89720
89721
89722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89723   void * jresult ;
89724   unsigned int arg1 ;
89725   float arg2 ;
89726   Dali::Pixel::Format arg3 ;
89727   float arg4 ;
89728   float arg5 ;
89729   bool arg6 ;
89730   Dali::Toolkit::GaussianBlurView result;
89731
89732   arg1 = (unsigned int)jarg1;
89733   arg2 = (float)jarg2;
89734   arg3 = (Dali::Pixel::Format)jarg3;
89735   arg4 = (float)jarg4;
89736   arg5 = (float)jarg5;
89737   arg6 = jarg6 ? true : false;
89738   {
89739     try {
89740       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89741     } catch (std::out_of_range& e) {
89742       {
89743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89744       };
89745     } catch (std::exception& e) {
89746       {
89747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89748       };
89749     } catch (Dali::DaliException e) {
89750       {
89751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89752       };
89753     } catch (...) {
89754       {
89755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89756       };
89757     }
89758   }
89759
89760   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89761   return jresult;
89762 }
89763
89764
89765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89766   void * jresult ;
89767   unsigned int arg1 ;
89768   float arg2 ;
89769   Dali::Pixel::Format arg3 ;
89770   float arg4 ;
89771   float arg5 ;
89772   Dali::Toolkit::GaussianBlurView result;
89773
89774   arg1 = (unsigned int)jarg1;
89775   arg2 = (float)jarg2;
89776   arg3 = (Dali::Pixel::Format)jarg3;
89777   arg4 = (float)jarg4;
89778   arg5 = (float)jarg5;
89779   {
89780     try {
89781       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89782     } catch (std::out_of_range& e) {
89783       {
89784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89785       };
89786     } catch (std::exception& e) {
89787       {
89788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89789       };
89790     } catch (Dali::DaliException e) {
89791       {
89792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89793       };
89794     } catch (...) {
89795       {
89796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89797       };
89798     }
89799   }
89800
89801   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89802   return jresult;
89803 }
89804
89805
89806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89807   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89808   Dali::Actor arg2 ;
89809   Dali::Actor *argp2 ;
89810
89811   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89812   argp2 = (Dali::Actor *)jarg2;
89813   if (!argp2) {
89814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89815     return ;
89816   }
89817   arg2 = *argp2;
89818   {
89819     try {
89820       (arg1)->Add(arg2);
89821     } catch (std::out_of_range& e) {
89822       {
89823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89824       };
89825     } catch (std::exception& e) {
89826       {
89827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89828       };
89829     } catch (Dali::DaliException e) {
89830       {
89831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89832       };
89833     } catch (...) {
89834       {
89835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89836       };
89837     }
89838   }
89839
89840 }
89841
89842
89843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89844   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89845   Dali::Actor arg2 ;
89846   Dali::Actor *argp2 ;
89847
89848   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89849   argp2 = (Dali::Actor *)jarg2;
89850   if (!argp2) {
89851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89852     return ;
89853   }
89854   arg2 = *argp2;
89855   {
89856     try {
89857       (arg1)->Remove(arg2);
89858     } catch (std::out_of_range& e) {
89859       {
89860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89861       };
89862     } catch (std::exception& e) {
89863       {
89864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89865       };
89866     } catch (Dali::DaliException e) {
89867       {
89868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89869       };
89870     } catch (...) {
89871       {
89872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89873       };
89874     }
89875   }
89876
89877 }
89878
89879
89880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89881   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89882
89883   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89884   {
89885     try {
89886       (arg1)->Activate();
89887     } catch (std::out_of_range& e) {
89888       {
89889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89890       };
89891     } catch (std::exception& e) {
89892       {
89893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89894       };
89895     } catch (Dali::DaliException e) {
89896       {
89897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89898       };
89899     } catch (...) {
89900       {
89901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89902       };
89903     }
89904   }
89905
89906 }
89907
89908
89909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89910   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89911
89912   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89913   {
89914     try {
89915       (arg1)->ActivateOnce();
89916     } catch (std::out_of_range& e) {
89917       {
89918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89919       };
89920     } catch (std::exception& e) {
89921       {
89922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89923       };
89924     } catch (Dali::DaliException e) {
89925       {
89926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89927       };
89928     } catch (...) {
89929       {
89930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89931       };
89932     }
89933   }
89934
89935 }
89936
89937
89938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89939   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89940
89941   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89942   {
89943     try {
89944       (arg1)->Deactivate();
89945     } catch (std::out_of_range& e) {
89946       {
89947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89948       };
89949     } catch (std::exception& e) {
89950       {
89951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89952       };
89953     } catch (Dali::DaliException e) {
89954       {
89955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89956       };
89957     } catch (...) {
89958       {
89959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89960       };
89961     }
89962   }
89963
89964 }
89965
89966
89967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89968   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89969   Dali::Image arg2 ;
89970   Dali::FrameBufferImage arg3 ;
89971   Dali::Image *argp2 ;
89972   Dali::FrameBufferImage *argp3 ;
89973
89974   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89975   argp2 = (Dali::Image *)jarg2;
89976   if (!argp2) {
89977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89978     return ;
89979   }
89980   arg2 = *argp2;
89981   argp3 = (Dali::FrameBufferImage *)jarg3;
89982   if (!argp3) {
89983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89984     return ;
89985   }
89986   arg3 = *argp3;
89987   {
89988     try {
89989       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89990     } catch (std::out_of_range& e) {
89991       {
89992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89993       };
89994     } catch (std::exception& e) {
89995       {
89996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89997       };
89998     } catch (Dali::DaliException e) {
89999       {
90000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90001       };
90002     } catch (...) {
90003       {
90004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90005       };
90006     }
90007   }
90008
90009 }
90010
90011
90012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
90013   int jresult ;
90014   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90015   Dali::Property::Index result;
90016
90017   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90018   {
90019     try {
90020       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
90021     } catch (std::out_of_range& e) {
90022       {
90023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90024       };
90025     } catch (std::exception& e) {
90026       {
90027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90028       };
90029     } catch (Dali::DaliException e) {
90030       {
90031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90032       };
90033     } catch (...) {
90034       {
90035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90036       };
90037     }
90038   }
90039
90040   jresult = result;
90041   return jresult;
90042 }
90043
90044
90045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
90046   void * jresult ;
90047   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90048   Dali::FrameBufferImage result;
90049
90050   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90051   {
90052     try {
90053       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
90054     } catch (std::out_of_range& e) {
90055       {
90056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90057       };
90058     } catch (std::exception& e) {
90059       {
90060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90061       };
90062     } catch (Dali::DaliException e) {
90063       {
90064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90065       };
90066     } catch (...) {
90067       {
90068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90069       };
90070     }
90071   }
90072
90073   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
90074   return jresult;
90075 }
90076
90077
90078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
90079   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90080   Dali::Vector4 *arg2 = 0 ;
90081
90082   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90083   arg2 = (Dali::Vector4 *)jarg2;
90084   if (!arg2) {
90085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
90086     return ;
90087   }
90088   {
90089     try {
90090       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
90091     } catch (std::out_of_range& e) {
90092       {
90093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90094       };
90095     } catch (std::exception& e) {
90096       {
90097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90098       };
90099     } catch (Dali::DaliException e) {
90100       {
90101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90102       };
90103     } catch (...) {
90104       {
90105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90106       };
90107     }
90108   }
90109
90110 }
90111
90112
90113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
90114   void * jresult ;
90115   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90116   Dali::Vector4 result;
90117
90118   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90119   {
90120     try {
90121       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
90122     } catch (std::out_of_range& e) {
90123       {
90124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90125       };
90126     } catch (std::exception& e) {
90127       {
90128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90129       };
90130     } catch (Dali::DaliException e) {
90131       {
90132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90133       };
90134     } catch (...) {
90135       {
90136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90137       };
90138     }
90139   }
90140
90141   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
90142   return jresult;
90143 }
90144
90145
90146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90147   void * jresult ;
90148   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90149   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90150
90151   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90152   {
90153     try {
90154       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90155     } catch (std::out_of_range& e) {
90156       {
90157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90158       };
90159     } catch (std::exception& e) {
90160       {
90161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90162       };
90163     } catch (Dali::DaliException e) {
90164       {
90165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90166       };
90167     } catch (...) {
90168       {
90169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90170       };
90171     }
90172   }
90173
90174   jresult = (void *)result;
90175   return jresult;
90176 }
90177
90178
90179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90180   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90181
90182   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90183   {
90184     try {
90185       delete arg1;
90186     } catch (std::out_of_range& e) {
90187       {
90188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90189       };
90190     } catch (std::exception& e) {
90191       {
90192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90193       };
90194     } catch (Dali::DaliException e) {
90195       {
90196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90197       };
90198     } catch (...) {
90199       {
90200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90201       };
90202     }
90203   }
90204
90205 }
90206
90207
90208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90209   unsigned int jresult ;
90210   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90211   unsigned int result;
90212
90213   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90214   {
90215     try {
90216       result = (unsigned int)(arg1)->GetNumberOfPages();
90217     } catch (std::out_of_range& e) {
90218       {
90219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90220       };
90221     } catch (std::exception& e) {
90222       {
90223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90224       };
90225     } catch (Dali::DaliException e) {
90226       {
90227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90228       };
90229     } catch (...) {
90230       {
90231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90232       };
90233     }
90234   }
90235
90236   jresult = result;
90237   return jresult;
90238 }
90239
90240
90241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90242   void * jresult ;
90243   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90244   unsigned int arg2 ;
90245   Dali::Texture result;
90246
90247   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90248   arg2 = (unsigned int)jarg2;
90249   {
90250     try {
90251       result = (arg1)->NewPage(arg2);
90252     } catch (std::out_of_range& e) {
90253       {
90254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90255       };
90256     } catch (std::exception& e) {
90257       {
90258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90259       };
90260     } catch (Dali::DaliException e) {
90261       {
90262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90263       };
90264     } catch (...) {
90265       {
90266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90267       };
90268     }
90269   }
90270
90271   jresult = new Dali::Texture((const Dali::Texture &)result);
90272   return jresult;
90273 }
90274
90275
90276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90277   int jresult ;
90278   int result;
90279
90280   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90281   jresult = (int)result;
90282   return jresult;
90283 }
90284
90285
90286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90287   int jresult ;
90288   int result;
90289
90290   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90291   jresult = (int)result;
90292   return jresult;
90293 }
90294
90295
90296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90297   int jresult ;
90298   int result;
90299
90300   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90301   jresult = (int)result;
90302   return jresult;
90303 }
90304
90305
90306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90307   void * jresult ;
90308   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90309
90310   {
90311     try {
90312       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
90313     } catch (std::out_of_range& e) {
90314       {
90315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90316       };
90317     } catch (std::exception& e) {
90318       {
90319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90320       };
90321     } catch (Dali::DaliException e) {
90322       {
90323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90324       };
90325     } catch (...) {
90326       {
90327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90328       };
90329     }
90330   }
90331
90332   jresult = (void *)result;
90333   return jresult;
90334 }
90335
90336
90337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90338   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90339
90340   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90341   {
90342     try {
90343       delete arg1;
90344     } catch (std::out_of_range& e) {
90345       {
90346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90347       };
90348     } catch (std::exception& e) {
90349       {
90350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90351       };
90352     } catch (Dali::DaliException e) {
90353       {
90354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90355       };
90356     } catch (...) {
90357       {
90358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90359       };
90360     }
90361   }
90362
90363 }
90364
90365
90366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90367   void * jresult ;
90368   Dali::Toolkit::PageTurnView *result = 0 ;
90369
90370   {
90371     try {
90372       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90373     } catch (std::out_of_range& e) {
90374       {
90375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90376       };
90377     } catch (std::exception& e) {
90378       {
90379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90380       };
90381     } catch (Dali::DaliException e) {
90382       {
90383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90384       };
90385     } catch (...) {
90386       {
90387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90388       };
90389     }
90390   }
90391
90392   jresult = (void *)result;
90393   return jresult;
90394 }
90395
90396
90397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90398   void * jresult ;
90399   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90400   Dali::Toolkit::PageTurnView *result = 0 ;
90401
90402   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90403   if (!arg1) {
90404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90405     return 0;
90406   }
90407   {
90408     try {
90409       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90410     } catch (std::out_of_range& e) {
90411       {
90412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90413       };
90414     } catch (std::exception& e) {
90415       {
90416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90417       };
90418     } catch (Dali::DaliException e) {
90419       {
90420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90421       };
90422     } catch (...) {
90423       {
90424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90425       };
90426     }
90427   }
90428
90429   jresult = (void *)result;
90430   return jresult;
90431 }
90432
90433
90434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90435   void * jresult ;
90436   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90437   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90438   Dali::Toolkit::PageTurnView *result = 0 ;
90439
90440   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90441   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90442   if (!arg2) {
90443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90444     return 0;
90445   }
90446   {
90447     try {
90448       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90449     } catch (std::out_of_range& e) {
90450       {
90451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90452       };
90453     } catch (std::exception& e) {
90454       {
90455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90456       };
90457     } catch (Dali::DaliException e) {
90458       {
90459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90460       };
90461     } catch (...) {
90462       {
90463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90464       };
90465     }
90466   }
90467
90468   jresult = (void *)result;
90469   return jresult;
90470 }
90471
90472
90473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90474   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90475
90476   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90477   {
90478     try {
90479       delete arg1;
90480     } catch (std::out_of_range& e) {
90481       {
90482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90483       };
90484     } catch (std::exception& e) {
90485       {
90486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90487       };
90488     } catch (Dali::DaliException e) {
90489       {
90490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90491       };
90492     } catch (...) {
90493       {
90494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90495       };
90496     }
90497   }
90498
90499 }
90500
90501
90502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90503   void * jresult ;
90504   Dali::BaseHandle arg1 ;
90505   Dali::BaseHandle *argp1 ;
90506   Dali::Toolkit::PageTurnView result;
90507
90508   argp1 = (Dali::BaseHandle *)jarg1;
90509   if (!argp1) {
90510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90511     return 0;
90512   }
90513   arg1 = *argp1;
90514   {
90515     try {
90516       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
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 = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90537   return jresult;
90538 }
90539
90540
90541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90542   void * jresult ;
90543   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90544   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90545
90546   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90547   {
90548     try {
90549       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90550     } catch (std::out_of_range& e) {
90551       {
90552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90553       };
90554     } catch (std::exception& e) {
90555       {
90556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90557       };
90558     } catch (Dali::DaliException e) {
90559       {
90560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90561       };
90562     } catch (...) {
90563       {
90564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90565       };
90566     }
90567   }
90568
90569   jresult = (void *)result;
90570   return jresult;
90571 }
90572
90573
90574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90575   void * jresult ;
90576   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90577   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90578
90579   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90580   {
90581     try {
90582       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90583     } catch (std::out_of_range& e) {
90584       {
90585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90586       };
90587     } catch (std::exception& e) {
90588       {
90589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90590       };
90591     } catch (Dali::DaliException e) {
90592       {
90593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90594       };
90595     } catch (...) {
90596       {
90597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90598       };
90599     }
90600   }
90601
90602   jresult = (void *)result;
90603   return jresult;
90604 }
90605
90606
90607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90608   void * jresult ;
90609   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90610   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90611
90612   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90613   {
90614     try {
90615       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
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 = (void *)result;
90636   return jresult;
90637 }
90638
90639
90640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90641   void * jresult ;
90642   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90643   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90644
90645   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90646   {
90647     try {
90648       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90649     } catch (std::out_of_range& e) {
90650       {
90651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90652       };
90653     } catch (std::exception& e) {
90654       {
90655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90656       };
90657     } catch (Dali::DaliException e) {
90658       {
90659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90660       };
90661     } catch (...) {
90662       {
90663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90664       };
90665     }
90666   }
90667
90668   jresult = (void *)result;
90669   return jresult;
90670 }
90671
90672
90673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90674   void * jresult ;
90675   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90676
90677   {
90678     try {
90679       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90680     } catch (std::out_of_range& e) {
90681       {
90682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90683       };
90684     } catch (std::exception& e) {
90685       {
90686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90687       };
90688     } catch (Dali::DaliException e) {
90689       {
90690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90691       };
90692     } catch (...) {
90693       {
90694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90695       };
90696     }
90697   }
90698
90699   jresult = (void *)result;
90700   return jresult;
90701 }
90702
90703
90704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90705   void * jresult ;
90706   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90707   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90708
90709   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90710   if (!arg1) {
90711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90712     return 0;
90713   }
90714   {
90715     try {
90716       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90717     } catch (std::out_of_range& e) {
90718       {
90719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90720       };
90721     } catch (std::exception& e) {
90722       {
90723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90724       };
90725     } catch (Dali::DaliException e) {
90726       {
90727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90728       };
90729     } catch (...) {
90730       {
90731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90732       };
90733     }
90734   }
90735
90736   jresult = (void *)result;
90737   return jresult;
90738 }
90739
90740
90741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90742   void * jresult ;
90743   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90744   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90745   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90746
90747   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90748   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90749   if (!arg2) {
90750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90751     return 0;
90752   }
90753   {
90754     try {
90755       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90756     } catch (std::out_of_range& e) {
90757       {
90758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90759       };
90760     } catch (std::exception& e) {
90761       {
90762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90763       };
90764     } catch (Dali::DaliException e) {
90765       {
90766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90767       };
90768     } catch (...) {
90769       {
90770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90771       };
90772     }
90773   }
90774
90775   jresult = (void *)result;
90776   return jresult;
90777 }
90778
90779
90780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90781   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90782
90783   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90784   {
90785     try {
90786       delete arg1;
90787     } catch (std::out_of_range& e) {
90788       {
90789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90790       };
90791     } catch (std::exception& e) {
90792       {
90793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90794       };
90795     } catch (Dali::DaliException e) {
90796       {
90797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90798       };
90799     } catch (...) {
90800       {
90801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90802       };
90803     }
90804   }
90805
90806 }
90807
90808
90809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90810   void * jresult ;
90811   Dali::Toolkit::PageFactory *arg1 = 0 ;
90812   Dali::Vector2 *arg2 = 0 ;
90813   Dali::Toolkit::PageTurnLandscapeView result;
90814
90815   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90816   if (!arg1) {
90817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90818     return 0;
90819   }
90820   arg2 = (Dali::Vector2 *)jarg2;
90821   if (!arg2) {
90822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90823     return 0;
90824   }
90825   {
90826     try {
90827       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90828     } catch (std::out_of_range& e) {
90829       {
90830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90831       };
90832     } catch (std::exception& e) {
90833       {
90834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90835       };
90836     } catch (Dali::DaliException e) {
90837       {
90838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90839       };
90840     } catch (...) {
90841       {
90842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90843       };
90844     }
90845   }
90846
90847   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90848   return jresult;
90849 }
90850
90851
90852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90853   void * jresult ;
90854   Dali::BaseHandle arg1 ;
90855   Dali::BaseHandle *argp1 ;
90856   Dali::Toolkit::PageTurnLandscapeView result;
90857
90858   argp1 = (Dali::BaseHandle *)jarg1;
90859   if (!argp1) {
90860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90861     return 0;
90862   }
90863   arg1 = *argp1;
90864   {
90865     try {
90866       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90867     } catch (std::out_of_range& e) {
90868       {
90869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90870       };
90871     } catch (std::exception& e) {
90872       {
90873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90874       };
90875     } catch (Dali::DaliException e) {
90876       {
90877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90878       };
90879     } catch (...) {
90880       {
90881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90882       };
90883     }
90884   }
90885
90886   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90887   return jresult;
90888 }
90889
90890
90891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90892   void * jresult ;
90893   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90894
90895   {
90896     try {
90897       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90898     } catch (std::out_of_range& e) {
90899       {
90900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90901       };
90902     } catch (std::exception& e) {
90903       {
90904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90905       };
90906     } catch (Dali::DaliException e) {
90907       {
90908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90909       };
90910     } catch (...) {
90911       {
90912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90913       };
90914     }
90915   }
90916
90917   jresult = (void *)result;
90918   return jresult;
90919 }
90920
90921
90922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90923   void * jresult ;
90924   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90925   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90926
90927   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90928   if (!arg1) {
90929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90930     return 0;
90931   }
90932   {
90933     try {
90934       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90935     } catch (std::out_of_range& e) {
90936       {
90937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90938       };
90939     } catch (std::exception& e) {
90940       {
90941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90942       };
90943     } catch (Dali::DaliException e) {
90944       {
90945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90946       };
90947     } catch (...) {
90948       {
90949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90950       };
90951     }
90952   }
90953
90954   jresult = (void *)result;
90955   return jresult;
90956 }
90957
90958
90959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90960   void * jresult ;
90961   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90962   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90963   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90964
90965   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90966   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90967   if (!arg2) {
90968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90969     return 0;
90970   }
90971   {
90972     try {
90973       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90974     } catch (std::out_of_range& e) {
90975       {
90976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90977       };
90978     } catch (std::exception& e) {
90979       {
90980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90981       };
90982     } catch (Dali::DaliException e) {
90983       {
90984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90985       };
90986     } catch (...) {
90987       {
90988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90989       };
90990     }
90991   }
90992
90993   jresult = (void *)result;
90994   return jresult;
90995 }
90996
90997
90998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90999   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
91000
91001   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
91002   {
91003     try {
91004       delete arg1;
91005     } catch (std::out_of_range& e) {
91006       {
91007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91008       };
91009     } catch (std::exception& e) {
91010       {
91011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91012       };
91013     } catch (Dali::DaliException e) {
91014       {
91015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91016       };
91017     } catch (...) {
91018       {
91019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91020       };
91021     }
91022   }
91023
91024 }
91025
91026
91027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
91028   void * jresult ;
91029   Dali::Toolkit::PageFactory *arg1 = 0 ;
91030   Dali::Vector2 *arg2 = 0 ;
91031   Dali::Toolkit::PageTurnPortraitView result;
91032
91033   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
91034   if (!arg1) {
91035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
91036     return 0;
91037   }
91038   arg2 = (Dali::Vector2 *)jarg2;
91039   if (!arg2) {
91040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91041     return 0;
91042   }
91043   {
91044     try {
91045       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
91046     } catch (std::out_of_range& e) {
91047       {
91048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91049       };
91050     } catch (std::exception& e) {
91051       {
91052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91053       };
91054     } catch (Dali::DaliException e) {
91055       {
91056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91057       };
91058     } catch (...) {
91059       {
91060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91061       };
91062     }
91063   }
91064
91065   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91066   return jresult;
91067 }
91068
91069
91070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
91071   void * jresult ;
91072   Dali::BaseHandle arg1 ;
91073   Dali::BaseHandle *argp1 ;
91074   Dali::Toolkit::PageTurnPortraitView result;
91075
91076   argp1 = (Dali::BaseHandle *)jarg1;
91077   if (!argp1) {
91078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91079     return 0;
91080   }
91081   arg1 = *argp1;
91082   {
91083     try {
91084       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
91085     } catch (std::out_of_range& e) {
91086       {
91087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91088       };
91089     } catch (std::exception& e) {
91090       {
91091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91092       };
91093     } catch (Dali::DaliException e) {
91094       {
91095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91096       };
91097     } catch (...) {
91098       {
91099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91100       };
91101     }
91102   }
91103
91104   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91105   return jresult;
91106 }
91107
91108
91109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
91110   int jresult ;
91111   int result;
91112
91113   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
91114   jresult = (int)result;
91115   return jresult;
91116 }
91117
91118
91119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
91120   int jresult ;
91121   int result;
91122
91123   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
91124   jresult = (int)result;
91125   return jresult;
91126 }
91127
91128
91129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
91130   int jresult ;
91131   int result;
91132
91133   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
91134   jresult = (int)result;
91135   return jresult;
91136 }
91137
91138
91139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
91140   void * jresult ;
91141   Dali::Toolkit::ToggleButton::Property *result = 0 ;
91142
91143   {
91144     try {
91145       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91146     } catch (std::out_of_range& e) {
91147       {
91148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91149       };
91150     } catch (std::exception& e) {
91151       {
91152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91153       };
91154     } catch (Dali::DaliException e) {
91155       {
91156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91157       };
91158     } catch (...) {
91159       {
91160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91161       };
91162     }
91163   }
91164
91165   jresult = (void *)result;
91166   return jresult;
91167 }
91168
91169
91170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91171   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91172
91173   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91174   {
91175     try {
91176       delete arg1;
91177     } catch (std::out_of_range& e) {
91178       {
91179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91180       };
91181     } catch (std::exception& e) {
91182       {
91183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91184       };
91185     } catch (Dali::DaliException e) {
91186       {
91187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91188       };
91189     } catch (...) {
91190       {
91191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91192       };
91193     }
91194   }
91195
91196 }
91197
91198
91199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91200   void * jresult ;
91201   Dali::Toolkit::ToggleButton *result = 0 ;
91202
91203   {
91204     try {
91205       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91206     } catch (std::out_of_range& e) {
91207       {
91208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91209       };
91210     } catch (std::exception& e) {
91211       {
91212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91213       };
91214     } catch (Dali::DaliException e) {
91215       {
91216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91217       };
91218     } catch (...) {
91219       {
91220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91221       };
91222     }
91223   }
91224
91225   jresult = (void *)result;
91226   return jresult;
91227 }
91228
91229
91230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91231   void * jresult ;
91232   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91233   Dali::Toolkit::ToggleButton *result = 0 ;
91234
91235   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91236   if (!arg1) {
91237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91238     return 0;
91239   }
91240   {
91241     try {
91242       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
91243     } catch (std::out_of_range& e) {
91244       {
91245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91246       };
91247     } catch (std::exception& e) {
91248       {
91249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91250       };
91251     } catch (Dali::DaliException e) {
91252       {
91253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91254       };
91255     } catch (...) {
91256       {
91257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91258       };
91259     }
91260   }
91261
91262   jresult = (void *)result;
91263   return jresult;
91264 }
91265
91266
91267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
91268   void * jresult ;
91269   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91270   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91271   Dali::Toolkit::ToggleButton *result = 0 ;
91272
91273   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91274   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91275   if (!arg2) {
91276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91277     return 0;
91278   }
91279   {
91280     try {
91281       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91282     } catch (std::out_of_range& e) {
91283       {
91284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91285       };
91286     } catch (std::exception& e) {
91287       {
91288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91289       };
91290     } catch (Dali::DaliException e) {
91291       {
91292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91293       };
91294     } catch (...) {
91295       {
91296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91297       };
91298     }
91299   }
91300
91301   jresult = (void *)result;
91302   return jresult;
91303 }
91304
91305
91306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91307   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91308
91309   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91310   {
91311     try {
91312       delete arg1;
91313     } catch (std::out_of_range& e) {
91314       {
91315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91316       };
91317     } catch (std::exception& e) {
91318       {
91319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91320       };
91321     } catch (Dali::DaliException e) {
91322       {
91323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91324       };
91325     } catch (...) {
91326       {
91327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91328       };
91329     }
91330   }
91331
91332 }
91333
91334
91335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91336   void * jresult ;
91337   Dali::Toolkit::ToggleButton result;
91338
91339   {
91340     try {
91341       result = Dali::Toolkit::ToggleButton::New();
91342     } catch (std::out_of_range& e) {
91343       {
91344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91345       };
91346     } catch (std::exception& e) {
91347       {
91348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91349       };
91350     } catch (Dali::DaliException e) {
91351       {
91352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91353       };
91354     } catch (...) {
91355       {
91356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91357       };
91358     }
91359   }
91360
91361   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91362   return jresult;
91363 }
91364
91365
91366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91367   void * jresult ;
91368   Dali::BaseHandle arg1 ;
91369   Dali::BaseHandle *argp1 ;
91370   Dali::Toolkit::ToggleButton result;
91371
91372   argp1 = (Dali::BaseHandle *)jarg1;
91373   if (!argp1) {
91374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91375     return 0;
91376   }
91377   arg1 = *argp1;
91378   {
91379     try {
91380       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91381     } catch (std::out_of_range& e) {
91382       {
91383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91384       };
91385     } catch (std::exception& e) {
91386       {
91387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91388       };
91389     } catch (Dali::DaliException e) {
91390       {
91391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91392       };
91393     } catch (...) {
91394       {
91395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91396       };
91397     }
91398   }
91399
91400   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91401   return jresult;
91402 }
91403
91404
91405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91406   void * jresult ;
91407   Dali::Toolkit::Visual::Base *result = 0 ;
91408
91409   {
91410     try {
91411       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91412     } catch (std::out_of_range& e) {
91413       {
91414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91415       };
91416     } catch (std::exception& e) {
91417       {
91418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91419       };
91420     } catch (Dali::DaliException e) {
91421       {
91422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91423       };
91424     } catch (...) {
91425       {
91426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91427       };
91428     }
91429   }
91430
91431   jresult = (void *)result;
91432   return jresult;
91433 }
91434
91435
91436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91437   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91438
91439   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91440   {
91441     try {
91442       delete arg1;
91443     } catch (std::out_of_range& e) {
91444       {
91445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91446       };
91447     } catch (std::exception& e) {
91448       {
91449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91450       };
91451     } catch (Dali::DaliException e) {
91452       {
91453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91454       };
91455     } catch (...) {
91456       {
91457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91458       };
91459     }
91460   }
91461
91462 }
91463
91464
91465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91466   void * jresult ;
91467   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91468   Dali::Toolkit::Visual::Base *result = 0 ;
91469
91470   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91471   if (!arg1) {
91472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91473     return 0;
91474   }
91475   {
91476     try {
91477       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91478     } catch (std::out_of_range& e) {
91479       {
91480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91481       };
91482     } catch (std::exception& e) {
91483       {
91484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91485       };
91486     } catch (Dali::DaliException e) {
91487       {
91488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91489       };
91490     } catch (...) {
91491       {
91492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91493       };
91494     }
91495   }
91496
91497   jresult = (void *)result;
91498   return jresult;
91499 }
91500
91501
91502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91503   void * jresult ;
91504   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91505   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91506   Dali::Toolkit::Visual::Base *result = 0 ;
91507
91508   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91509   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91510   if (!arg2) {
91511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91512     return 0;
91513   }
91514   {
91515     try {
91516       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91517     } catch (std::out_of_range& e) {
91518       {
91519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91520       };
91521     } catch (std::exception& e) {
91522       {
91523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91524       };
91525     } catch (Dali::DaliException e) {
91526       {
91527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91528       };
91529     } catch (...) {
91530       {
91531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91532       };
91533     }
91534   }
91535
91536   jresult = (void *)result;
91537   return jresult;
91538 }
91539
91540
91541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91542   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91543   std::string *arg2 = 0 ;
91544
91545   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91546   if (!jarg2) {
91547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91548     return ;
91549   }
91550   std::string arg2_str(jarg2);
91551   arg2 = &arg2_str;
91552   {
91553     try {
91554       (arg1)->SetName((std::string const &)*arg2);
91555     } catch (std::out_of_range& e) {
91556       {
91557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91558       };
91559     } catch (std::exception& e) {
91560       {
91561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91562       };
91563     } catch (Dali::DaliException e) {
91564       {
91565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91566       };
91567     } catch (...) {
91568       {
91569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91570       };
91571     }
91572   }
91573
91574
91575   //argout typemap for const std::string&
91576
91577 }
91578
91579
91580 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91581   char * jresult ;
91582   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91583   std::string *result = 0 ;
91584
91585   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91586   {
91587     try {
91588       result = (std::string *) &(arg1)->GetName();
91589     } catch (std::out_of_range& e) {
91590       {
91591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91592       };
91593     } catch (std::exception& e) {
91594       {
91595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91596       };
91597     } catch (Dali::DaliException e) {
91598       {
91599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91600       };
91601     } catch (...) {
91602       {
91603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91604       };
91605     }
91606   }
91607
91608   jresult = SWIG_csharp_string_callback(result->c_str());
91609   return jresult;
91610 }
91611
91612
91613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91614   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91615   Dali::Property::Map *arg2 = 0 ;
91616   Dali::Size arg3 ;
91617   Dali::Size *argp3 ;
91618
91619   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91620   arg2 = (Dali::Property::Map *)jarg2;
91621   if (!arg2) {
91622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91623     return ;
91624   }
91625   argp3 = (Dali::Size *)jarg3;
91626   if (!argp3) {
91627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91628     return ;
91629   }
91630   arg3 = *argp3;
91631   {
91632     try {
91633       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91634     } catch (std::out_of_range& e) {
91635       {
91636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91637       };
91638     } catch (std::exception& e) {
91639       {
91640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91641       };
91642     } catch (Dali::DaliException e) {
91643       {
91644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91645       };
91646     } catch (...) {
91647       {
91648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91649       };
91650     }
91651   }
91652
91653 }
91654
91655
91656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91657   float jresult ;
91658   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91659   float arg2 ;
91660   float result;
91661
91662   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91663   arg2 = (float)jarg2;
91664   {
91665     try {
91666       result = (float)(arg1)->GetHeightForWidth(arg2);
91667     } catch (std::out_of_range& e) {
91668       {
91669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91670       };
91671     } catch (std::exception& e) {
91672       {
91673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91674       };
91675     } catch (Dali::DaliException e) {
91676       {
91677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91678       };
91679     } catch (...) {
91680       {
91681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91682       };
91683     }
91684   }
91685
91686   jresult = result;
91687   return jresult;
91688 }
91689
91690
91691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91692   float jresult ;
91693   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91694   float arg2 ;
91695   float result;
91696
91697   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91698   arg2 = (float)jarg2;
91699   {
91700     try {
91701       result = (float)(arg1)->GetWidthForHeight(arg2);
91702     } catch (std::out_of_range& e) {
91703       {
91704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91705       };
91706     } catch (std::exception& e) {
91707       {
91708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91709       };
91710     } catch (Dali::DaliException e) {
91711       {
91712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91713       };
91714     } catch (...) {
91715       {
91716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91717       };
91718     }
91719   }
91720
91721   jresult = result;
91722   return jresult;
91723 }
91724
91725
91726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91727   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91728   Dali::Vector2 *arg2 = 0 ;
91729
91730   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91731   arg2 = (Dali::Vector2 *)jarg2;
91732   if (!arg2) {
91733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91734     return ;
91735   }
91736   {
91737     try {
91738       (arg1)->GetNaturalSize(*arg2);
91739     } catch (std::out_of_range& e) {
91740       {
91741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91742       };
91743     } catch (std::exception& e) {
91744       {
91745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91746       };
91747     } catch (Dali::DaliException e) {
91748       {
91749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91750       };
91751     } catch (...) {
91752       {
91753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91754       };
91755     }
91756   }
91757
91758 }
91759
91760
91761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91762   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91763   float arg2 ;
91764
91765   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91766   arg2 = (int)jarg2;
91767   {
91768     try {
91769       (arg1)->SetDepthIndex(arg2);
91770     } catch (std::out_of_range& e) {
91771       {
91772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91773       };
91774     } catch (std::exception& e) {
91775       {
91776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91777       };
91778     } catch (Dali::DaliException e) {
91779       {
91780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91781       };
91782     } catch (...) {
91783       {
91784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91785       };
91786     }
91787   }
91788
91789 }
91790
91791
91792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91793   int jresult ;
91794   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91795   int result;
91796
91797   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91798   {
91799     try {
91800       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91801     } catch (std::out_of_range& e) {
91802       {
91803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91804       };
91805     } catch (std::exception& e) {
91806       {
91807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91808       };
91809     } catch (Dali::DaliException e) {
91810       {
91811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91812       };
91813     } catch (...) {
91814       {
91815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91816       };
91817     }
91818   }
91819
91820   jresult = result;
91821   return jresult;
91822 }
91823
91824
91825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91826   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91827   Dali::Property::Map *arg2 = 0 ;
91828
91829   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91830   arg2 = (Dali::Property::Map *)jarg2;
91831   if (!arg2) {
91832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91833     return ;
91834   }
91835   {
91836     try {
91837       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91838     } catch (std::out_of_range& e) {
91839       {
91840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91841       };
91842     } catch (std::exception& e) {
91843       {
91844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91845       };
91846     } catch (Dali::DaliException e) {
91847       {
91848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91849       };
91850     } catch (...) {
91851       {
91852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91853       };
91854     }
91855   }
91856
91857 }
91858
91859
91860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91861   void * jresult ;
91862   Dali::Toolkit::VisualFactory result;
91863
91864   {
91865     try {
91866       result = Dali::Toolkit::VisualFactory::Get();
91867     } catch (std::out_of_range& e) {
91868       {
91869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91870       };
91871     } catch (std::exception& e) {
91872       {
91873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91874       };
91875     } catch (Dali::DaliException e) {
91876       {
91877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91878       };
91879     } catch (...) {
91880       {
91881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91882       };
91883     }
91884   }
91885
91886   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91887   return jresult;
91888 }
91889
91890
91891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91892   void * jresult ;
91893   Dali::Toolkit::VisualFactory *result = 0 ;
91894
91895   {
91896     try {
91897       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91898     } catch (std::out_of_range& e) {
91899       {
91900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91901       };
91902     } catch (std::exception& e) {
91903       {
91904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91905       };
91906     } catch (Dali::DaliException e) {
91907       {
91908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91909       };
91910     } catch (...) {
91911       {
91912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91913       };
91914     }
91915   }
91916
91917   jresult = (void *)result;
91918   return jresult;
91919 }
91920
91921
91922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91923   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91924
91925   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91926   {
91927     try {
91928       delete arg1;
91929     } catch (std::out_of_range& e) {
91930       {
91931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91932       };
91933     } catch (std::exception& e) {
91934       {
91935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91936       };
91937     } catch (Dali::DaliException e) {
91938       {
91939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91940       };
91941     } catch (...) {
91942       {
91943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91944       };
91945     }
91946   }
91947
91948 }
91949
91950
91951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91952   void * jresult ;
91953   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91954   Dali::Toolkit::VisualFactory *result = 0 ;
91955
91956   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91957   if (!arg1) {
91958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91959     return 0;
91960   }
91961   {
91962     try {
91963       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91964     } catch (std::out_of_range& e) {
91965       {
91966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91967       };
91968     } catch (std::exception& e) {
91969       {
91970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91971       };
91972     } catch (Dali::DaliException e) {
91973       {
91974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91975       };
91976     } catch (...) {
91977       {
91978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91979       };
91980     }
91981   }
91982
91983   jresult = (void *)result;
91984   return jresult;
91985 }
91986
91987
91988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91989   void * jresult ;
91990   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91991   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91992   Dali::Toolkit::VisualFactory *result = 0 ;
91993
91994   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91995   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91996   if (!arg2) {
91997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91998     return 0;
91999   }
92000   {
92001     try {
92002       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
92003     } catch (std::out_of_range& e) {
92004       {
92005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92006       };
92007     } catch (std::exception& e) {
92008       {
92009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92010       };
92011     } catch (Dali::DaliException e) {
92012       {
92013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92014       };
92015     } catch (...) {
92016       {
92017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92018       };
92019     }
92020   }
92021
92022   jresult = (void *)result;
92023   return jresult;
92024 }
92025
92026
92027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
92028   void * jresult ;
92029   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92030   Dali::Property::Map *arg2 = 0 ;
92031   Dali::Toolkit::Visual::Base result;
92032
92033   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92034   arg2 = (Dali::Property::Map *)jarg2;
92035   if (!arg2) {
92036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
92037     return 0;
92038   }
92039   {
92040     try {
92041       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
92042     } catch (std::out_of_range& e) {
92043       {
92044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92045       };
92046     } catch (std::exception& e) {
92047       {
92048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92049       };
92050     } catch (Dali::DaliException e) {
92051       {
92052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92053       };
92054     } catch (...) {
92055       {
92056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92057       };
92058     }
92059   }
92060
92061   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92062   return jresult;
92063 }
92064
92065
92066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
92067   void * jresult ;
92068   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92069   Dali::Image *arg2 = 0 ;
92070   Dali::Toolkit::Visual::Base result;
92071
92072   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92073   arg2 = (Dali::Image *)jarg2;
92074   if (!arg2) {
92075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
92076     return 0;
92077   }
92078   {
92079     try {
92080       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
92081     } catch (std::out_of_range& e) {
92082       {
92083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92084       };
92085     } catch (std::exception& e) {
92086       {
92087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92088       };
92089     } catch (Dali::DaliException e) {
92090       {
92091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92092       };
92093     } catch (...) {
92094       {
92095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92096       };
92097     }
92098   }
92099
92100   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92101   return jresult;
92102 }
92103
92104
92105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
92106   void * jresult ;
92107   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92108   std::string *arg2 = 0 ;
92109   Dali::ImageDimensions arg3 ;
92110   Dali::ImageDimensions *argp3 ;
92111   Dali::Toolkit::Visual::Base result;
92112
92113   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92114   if (!jarg2) {
92115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92116     return 0;
92117   }
92118   std::string arg2_str(jarg2);
92119   arg2 = &arg2_str;
92120   argp3 = (Dali::ImageDimensions *)jarg3;
92121   if (!argp3) {
92122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92123     return 0;
92124   }
92125   arg3 = *argp3;
92126   {
92127     try {
92128       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
92129     } catch (std::out_of_range& e) {
92130       {
92131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92132       };
92133     } catch (std::exception& e) {
92134       {
92135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92136       };
92137     } catch (Dali::DaliException e) {
92138       {
92139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92140       };
92141     } catch (...) {
92142       {
92143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92144       };
92145     }
92146   }
92147
92148   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92149
92150   //argout typemap for const std::string&
92151
92152   return jresult;
92153 }
92154
92155
92156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92157   void * jresult ;
92158   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92159
92160   {
92161     try {
92162       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92163     } catch (std::out_of_range& e) {
92164       {
92165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92166       };
92167     } catch (std::exception& e) {
92168       {
92169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92170       };
92171     } catch (Dali::DaliException e) {
92172       {
92173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92174       };
92175     } catch (...) {
92176       {
92177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92178       };
92179     }
92180   }
92181
92182   jresult = (void *)result;
92183   return jresult;
92184 }
92185
92186
92187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92188   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92189
92190   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92191   {
92192     try {
92193       delete arg1;
92194     } catch (std::out_of_range& e) {
92195       {
92196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92197       };
92198     } catch (std::exception& e) {
92199       {
92200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92201       };
92202     } catch (Dali::DaliException e) {
92203       {
92204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92205       };
92206     } catch (...) {
92207       {
92208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92209       };
92210     }
92211   }
92212
92213 }
92214
92215
92216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92217   void * jresult ;
92218   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92219   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92220
92221   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92222   if (!arg1) {
92223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92224     return 0;
92225   }
92226   {
92227     try {
92228       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
92229     } catch (std::out_of_range& e) {
92230       {
92231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92232       };
92233     } catch (std::exception& e) {
92234       {
92235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92236       };
92237     } catch (Dali::DaliException e) {
92238       {
92239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92240       };
92241     } catch (...) {
92242       {
92243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92244       };
92245     }
92246   }
92247
92248   jresult = (void *)result;
92249   return jresult;
92250 }
92251
92252
92253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92254   void * jresult ;
92255   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92256   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92257   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92258
92259   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92260   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92261   if (!arg2) {
92262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92263     return 0;
92264   }
92265   {
92266     try {
92267       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92268     } catch (std::out_of_range& e) {
92269       {
92270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92271       };
92272     } catch (std::exception& e) {
92273       {
92274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92275       };
92276     } catch (Dali::DaliException e) {
92277       {
92278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92279       };
92280     } catch (...) {
92281       {
92282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92283       };
92284     }
92285   }
92286
92287   jresult = (void *)result;
92288   return jresult;
92289 }
92290
92291
92292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92293   void * jresult ;
92294   Dali::Toolkit::AsyncImageLoader result;
92295
92296   {
92297     try {
92298       result = Dali::Toolkit::AsyncImageLoader::New();
92299     } catch (std::out_of_range& e) {
92300       {
92301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92302       };
92303     } catch (std::exception& e) {
92304       {
92305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92306       };
92307     } catch (Dali::DaliException e) {
92308       {
92309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92310       };
92311     } catch (...) {
92312       {
92313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92314       };
92315     }
92316   }
92317
92318   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92319   return jresult;
92320 }
92321
92322
92323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92324   void * jresult ;
92325   Dali::BaseHandle arg1 ;
92326   Dali::BaseHandle *argp1 ;
92327   Dali::Toolkit::AsyncImageLoader result;
92328
92329   argp1 = (Dali::BaseHandle *)jarg1;
92330   if (!argp1) {
92331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92332     return 0;
92333   }
92334   arg1 = *argp1;
92335   {
92336     try {
92337       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92338     } catch (std::out_of_range& e) {
92339       {
92340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92341       };
92342     } catch (std::exception& e) {
92343       {
92344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92345       };
92346     } catch (Dali::DaliException e) {
92347       {
92348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92349       };
92350     } catch (...) {
92351       {
92352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92353       };
92354     }
92355   }
92356
92357   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92358   return jresult;
92359 }
92360
92361
92362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92363   unsigned int jresult ;
92364   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92365   std::string *arg2 = 0 ;
92366   uint32_t result;
92367
92368   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92369   if (!jarg2) {
92370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92371     return 0;
92372   }
92373   std::string arg2_str(jarg2);
92374   arg2 = &arg2_str;
92375   {
92376     try {
92377       result = (arg1)->Load((std::string const &)*arg2);
92378     } catch (std::out_of_range& e) {
92379       {
92380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92381       };
92382     } catch (std::exception& e) {
92383       {
92384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92385       };
92386     } catch (Dali::DaliException e) {
92387       {
92388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92389       };
92390     } catch (...) {
92391       {
92392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92393       };
92394     }
92395   }
92396
92397   jresult = result;
92398
92399   //argout typemap for const std::string&
92400
92401   return jresult;
92402 }
92403
92404
92405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92406   unsigned int jresult ;
92407   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92408   std::string *arg2 = 0 ;
92409   Dali::ImageDimensions arg3 ;
92410   Dali::ImageDimensions *argp3 ;
92411   uint32_t result;
92412
92413   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92414   if (!jarg2) {
92415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92416     return 0;
92417   }
92418   std::string arg2_str(jarg2);
92419   arg2 = &arg2_str;
92420   argp3 = (Dali::ImageDimensions *)jarg3;
92421   if (!argp3) {
92422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92423     return 0;
92424   }
92425   arg3 = *argp3;
92426   {
92427     try {
92428       result = (arg1)->Load((std::string const &)*arg2,arg3);
92429     } catch (std::out_of_range& e) {
92430       {
92431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92432       };
92433     } catch (std::exception& e) {
92434       {
92435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92436       };
92437     } catch (Dali::DaliException e) {
92438       {
92439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92440       };
92441     } catch (...) {
92442       {
92443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92444       };
92445     }
92446   }
92447
92448   jresult = result;
92449
92450   //argout typemap for const std::string&
92451
92452   return jresult;
92453 }
92454
92455
92456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92457   unsigned int jresult ;
92458   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92459   std::string *arg2 = 0 ;
92460   Dali::ImageDimensions arg3 ;
92461   Dali::FittingMode::Type arg4 ;
92462   Dali::SamplingMode::Type arg5 ;
92463   bool arg6 ;
92464   Dali::ImageDimensions *argp3 ;
92465   uint32_t result;
92466
92467   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92468   if (!jarg2) {
92469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92470     return 0;
92471   }
92472   std::string arg2_str(jarg2);
92473   arg2 = &arg2_str;
92474   argp3 = (Dali::ImageDimensions *)jarg3;
92475   if (!argp3) {
92476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92477     return 0;
92478   }
92479   arg3 = *argp3;
92480   arg4 = (Dali::FittingMode::Type)jarg4;
92481   arg5 = (Dali::SamplingMode::Type)jarg5;
92482   arg6 = jarg6 ? true : false;
92483   {
92484     try {
92485       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92486     } catch (std::out_of_range& e) {
92487       {
92488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92489       };
92490     } catch (std::exception& e) {
92491       {
92492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92493       };
92494     } catch (Dali::DaliException e) {
92495       {
92496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92497       };
92498     } catch (...) {
92499       {
92500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92501       };
92502     }
92503   }
92504
92505   jresult = result;
92506
92507   //argout typemap for const std::string&
92508
92509   return jresult;
92510 }
92511
92512
92513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92514   unsigned int jresult ;
92515   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92516   uint32_t arg2 ;
92517   bool result;
92518
92519   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92520   arg2 = (uint32_t)jarg2;
92521   {
92522     try {
92523       result = (bool)(arg1)->Cancel(arg2);
92524     } catch (std::out_of_range& e) {
92525       {
92526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92527       };
92528     } catch (std::exception& e) {
92529       {
92530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92531       };
92532     } catch (Dali::DaliException e) {
92533       {
92534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92535       };
92536     } catch (...) {
92537       {
92538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92539       };
92540     }
92541   }
92542
92543   jresult = result;
92544   return jresult;
92545 }
92546
92547
92548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92549   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92550
92551   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92552   {
92553     try {
92554       (arg1)->CancelAll();
92555     } catch (std::out_of_range& e) {
92556       {
92557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92558       };
92559     } catch (std::exception& e) {
92560       {
92561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92562       };
92563     } catch (Dali::DaliException e) {
92564       {
92565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92566       };
92567     } catch (...) {
92568       {
92569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92570       };
92571     }
92572   }
92573
92574 }
92575
92576
92577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92578   void * jresult ;
92579   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92580   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92581
92582   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92583   {
92584     try {
92585       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92586     } catch (std::out_of_range& e) {
92587       {
92588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92589       };
92590     } catch (std::exception& e) {
92591       {
92592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92593       };
92594     } catch (Dali::DaliException e) {
92595       {
92596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92597       };
92598     } catch (...) {
92599       {
92600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92601       };
92602     }
92603   }
92604
92605   jresult = (void *)result;
92606   return jresult;
92607 }
92608
92609
92610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92611   void * jresult ;
92612   std::string *arg1 = 0 ;
92613   Dali::PixelData result;
92614
92615   if (!jarg1) {
92616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92617     return 0;
92618   }
92619   std::string arg1_str(jarg1);
92620   arg1 = &arg1_str;
92621   {
92622     try {
92623       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92624     } catch (std::out_of_range& e) {
92625       {
92626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92627       };
92628     } catch (std::exception& e) {
92629       {
92630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92631       };
92632     } catch (Dali::DaliException e) {
92633       {
92634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92635       };
92636     } catch (...) {
92637       {
92638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92639       };
92640     }
92641   }
92642
92643   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92644
92645   //argout typemap for const std::string&
92646
92647   return jresult;
92648 }
92649
92650
92651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92652   void * jresult ;
92653   std::string *arg1 = 0 ;
92654   Dali::ImageDimensions arg2 ;
92655   Dali::ImageDimensions *argp2 ;
92656   Dali::PixelData result;
92657
92658   if (!jarg1) {
92659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92660     return 0;
92661   }
92662   std::string arg1_str(jarg1);
92663   arg1 = &arg1_str;
92664   argp2 = (Dali::ImageDimensions *)jarg2;
92665   if (!argp2) {
92666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92667     return 0;
92668   }
92669   arg2 = *argp2;
92670   {
92671     try {
92672       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92673     } catch (std::out_of_range& e) {
92674       {
92675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92676       };
92677     } catch (std::exception& e) {
92678       {
92679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92680       };
92681     } catch (Dali::DaliException e) {
92682       {
92683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92684       };
92685     } catch (...) {
92686       {
92687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92688       };
92689     }
92690   }
92691
92692   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92693
92694   //argout typemap for const std::string&
92695
92696   return jresult;
92697 }
92698
92699
92700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92701   void * jresult ;
92702   std::string *arg1 = 0 ;
92703   Dali::ImageDimensions arg2 ;
92704   Dali::FittingMode::Type arg3 ;
92705   Dali::SamplingMode::Type arg4 ;
92706   bool arg5 ;
92707   Dali::ImageDimensions *argp2 ;
92708   Dali::PixelData result;
92709
92710   if (!jarg1) {
92711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92712     return 0;
92713   }
92714   std::string arg1_str(jarg1);
92715   arg1 = &arg1_str;
92716   argp2 = (Dali::ImageDimensions *)jarg2;
92717   if (!argp2) {
92718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92719     return 0;
92720   }
92721   arg2 = *argp2;
92722   arg3 = (Dali::FittingMode::Type)jarg3;
92723   arg4 = (Dali::SamplingMode::Type)jarg4;
92724   arg5 = jarg5 ? true : false;
92725   {
92726     try {
92727       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92728     } catch (std::out_of_range& e) {
92729       {
92730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92731       };
92732     } catch (std::exception& e) {
92733       {
92734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92735       };
92736     } catch (Dali::DaliException e) {
92737       {
92738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92739       };
92740     } catch (...) {
92741       {
92742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92743       };
92744     }
92745   }
92746
92747   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92748
92749   //argout typemap for const std::string&
92750
92751   return jresult;
92752 }
92753
92754
92755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92756   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92757
92758   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92759   {
92760     try {
92761       delete arg1;
92762     } catch (std::out_of_range& e) {
92763       {
92764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92765       };
92766     } catch (std::exception& e) {
92767       {
92768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92769       };
92770     } catch (Dali::DaliException e) {
92771       {
92772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92773       };
92774     } catch (...) {
92775       {
92776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92777       };
92778     }
92779   }
92780
92781 }
92782
92783
92784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92785   void * jresult ;
92786   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92787   Dali::Actor arg2 ;
92788   Dali::Actor arg3 ;
92789   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92790   Dali::Actor *argp2 ;
92791   Dali::Actor *argp3 ;
92792   Dali::Actor result;
92793
92794   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92795   argp2 = (Dali::Actor *)jarg2;
92796   if (!argp2) {
92797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92798     return 0;
92799   }
92800   arg2 = *argp2;
92801   argp3 = (Dali::Actor *)jarg3;
92802   if (!argp3) {
92803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92804     return 0;
92805   }
92806   arg3 = *argp3;
92807   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92808   {
92809     try {
92810       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92811     } catch (std::out_of_range& e) {
92812       {
92813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92814       };
92815     } catch (std::exception& e) {
92816       {
92817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92818       };
92819     } catch (Dali::DaliException e) {
92820       {
92821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92822       };
92823     } catch (...) {
92824       {
92825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92826       };
92827     }
92828   }
92829
92830   jresult = new Dali::Actor((const Dali::Actor &)result);
92831   return jresult;
92832 }
92833
92834
92835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92836   void * jresult ;
92837   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92838
92839   {
92840     try {
92841       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92842     } catch (std::out_of_range& e) {
92843       {
92844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92845       };
92846     } catch (std::exception& e) {
92847       {
92848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92849       };
92850     } catch (Dali::DaliException e) {
92851       {
92852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92853       };
92854     } catch (...) {
92855       {
92856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92857       };
92858     }
92859   }
92860
92861   jresult = (void *)result;
92862   return jresult;
92863 }
92864
92865
92866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92867   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92868   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92869   if (director) {
92870     director->swig_connect_director(callback0);
92871   }
92872 }
92873
92874
92875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92876   KeyboardFocusManager arg1 ;
92877   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92878   KeyboardFocusManager *argp1 ;
92879
92880   argp1 = (KeyboardFocusManager *)jarg1;
92881   if (!argp1) {
92882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92883     return ;
92884   }
92885   arg1 = *argp1;
92886   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92887   if (!arg2) {
92888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92889     return ;
92890   }
92891   {
92892     try {
92893       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92894     } catch (std::out_of_range& e) {
92895       {
92896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92897       };
92898     } catch (std::exception& e) {
92899       {
92900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92901       };
92902     } catch (Dali::DaliException e) {
92903       {
92904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92905       };
92906     } catch (...) {
92907       {
92908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92909       };
92910     }
92911   }
92912
92913 }
92914
92915
92916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92917   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92918
92919   arg1 = (std::vector< unsigned int > *)jarg1;
92920   {
92921     try {
92922       (arg1)->clear();
92923     } catch (std::out_of_range& e) {
92924       {
92925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92926       };
92927     } catch (std::exception& e) {
92928       {
92929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92930       };
92931     } catch (Dali::DaliException e) {
92932       {
92933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92934       };
92935     } catch (...) {
92936       {
92937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92938       };
92939     }
92940   }
92941
92942 }
92943
92944
92945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92946   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92947   unsigned int *arg2 = 0 ;
92948   unsigned int temp2 ;
92949
92950   arg1 = (std::vector< unsigned int > *)jarg1;
92951   temp2 = (unsigned int)jarg2;
92952   arg2 = &temp2;
92953   {
92954     try {
92955       (arg1)->push_back((unsigned int const &)*arg2);
92956     } catch (std::out_of_range& e) {
92957       {
92958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92959       };
92960     } catch (std::exception& e) {
92961       {
92962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92963       };
92964     } catch (Dali::DaliException e) {
92965       {
92966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92967       };
92968     } catch (...) {
92969       {
92970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92971       };
92972     }
92973   }
92974
92975 }
92976
92977
92978 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92979   unsigned long jresult ;
92980   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92981   std::vector< unsigned int >::size_type result;
92982
92983   arg1 = (std::vector< unsigned int > *)jarg1;
92984   {
92985     try {
92986       result = ((std::vector< unsigned int > const *)arg1)->size();
92987     } catch (std::out_of_range& e) {
92988       {
92989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92990       };
92991     } catch (std::exception& e) {
92992       {
92993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92994       };
92995     } catch (Dali::DaliException e) {
92996       {
92997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92998       };
92999     } catch (...) {
93000       {
93001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93002       };
93003     }
93004   }
93005
93006   jresult = (unsigned long)result;
93007   return jresult;
93008 }
93009
93010
93011 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
93012   unsigned long jresult ;
93013   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93014   std::vector< unsigned int >::size_type result;
93015
93016   arg1 = (std::vector< unsigned int > *)jarg1;
93017   {
93018     try {
93019       result = ((std::vector< unsigned int > const *)arg1)->capacity();
93020     } catch (std::out_of_range& e) {
93021       {
93022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93023       };
93024     } catch (std::exception& e) {
93025       {
93026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93027       };
93028     } catch (Dali::DaliException e) {
93029       {
93030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93031       };
93032     } catch (...) {
93033       {
93034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93035       };
93036     }
93037   }
93038
93039   jresult = (unsigned long)result;
93040   return jresult;
93041 }
93042
93043
93044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
93045   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93046   std::vector< unsigned int >::size_type arg2 ;
93047
93048   arg1 = (std::vector< unsigned int > *)jarg1;
93049   arg2 = (std::vector< unsigned int >::size_type)jarg2;
93050   {
93051     try {
93052       (arg1)->reserve(arg2);
93053     } catch (std::out_of_range& e) {
93054       {
93055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93056       };
93057     } catch (std::exception& e) {
93058       {
93059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93060       };
93061     } catch (Dali::DaliException e) {
93062       {
93063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93064       };
93065     } catch (...) {
93066       {
93067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93068       };
93069     }
93070   }
93071
93072 }
93073
93074
93075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
93076   void * jresult ;
93077   std::vector< unsigned int > *result = 0 ;
93078
93079   {
93080     try {
93081       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
93082     } catch (std::out_of_range& e) {
93083       {
93084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93085       };
93086     } catch (std::exception& e) {
93087       {
93088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93089       };
93090     } catch (Dali::DaliException e) {
93091       {
93092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93093       };
93094     } catch (...) {
93095       {
93096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93097       };
93098     }
93099   }
93100
93101   jresult = (void *)result;
93102   return jresult;
93103 }
93104
93105
93106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
93107   void * jresult ;
93108   std::vector< unsigned int > *arg1 = 0 ;
93109   std::vector< unsigned int > *result = 0 ;
93110
93111   arg1 = (std::vector< unsigned int > *)jarg1;
93112   if (!arg1) {
93113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93114     return 0;
93115   }
93116   {
93117     try {
93118       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
93119     } catch (std::out_of_range& e) {
93120       {
93121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93122       };
93123     } catch (std::exception& e) {
93124       {
93125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93126       };
93127     } catch (Dali::DaliException e) {
93128       {
93129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93130       };
93131     } catch (...) {
93132       {
93133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93134       };
93135     }
93136   }
93137
93138   jresult = (void *)result;
93139   return jresult;
93140 }
93141
93142
93143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
93144   void * jresult ;
93145   int arg1 ;
93146   std::vector< unsigned int > *result = 0 ;
93147
93148   arg1 = (int)jarg1;
93149   {
93150     try {
93151       try {
93152         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93153       }
93154       catch(std::out_of_range &_e) {
93155         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93156         return 0;
93157       }
93158
93159     } catch (std::out_of_range& e) {
93160       {
93161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93162       };
93163     } catch (std::exception& e) {
93164       {
93165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93166       };
93167     } catch (Dali::DaliException e) {
93168       {
93169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93170       };
93171     } catch (...) {
93172       {
93173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93174       };
93175     }
93176   }
93177
93178   jresult = (void *)result;
93179   return jresult;
93180 }
93181
93182
93183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93184   unsigned int jresult ;
93185   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93186   int arg2 ;
93187   unsigned int result;
93188
93189   arg1 = (std::vector< unsigned int > *)jarg1;
93190   arg2 = (int)jarg2;
93191   {
93192     try {
93193       try {
93194         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93195       }
93196       catch(std::out_of_range &_e) {
93197         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93198         return 0;
93199       }
93200
93201     } catch (std::out_of_range& e) {
93202       {
93203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93204       };
93205     } catch (std::exception& e) {
93206       {
93207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93208       };
93209     } catch (Dali::DaliException e) {
93210       {
93211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93212       };
93213     } catch (...) {
93214       {
93215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93216       };
93217     }
93218   }
93219
93220   jresult = result;
93221   return jresult;
93222 }
93223
93224
93225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93226   unsigned int jresult ;
93227   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93228   int arg2 ;
93229   unsigned int *result = 0 ;
93230
93231   arg1 = (std::vector< unsigned int > *)jarg1;
93232   arg2 = (int)jarg2;
93233   {
93234     try {
93235       try {
93236         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93237       }
93238       catch(std::out_of_range &_e) {
93239         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93240         return 0;
93241       }
93242
93243     } catch (std::out_of_range& e) {
93244       {
93245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93246       };
93247     } catch (std::exception& e) {
93248       {
93249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93250       };
93251     } catch (Dali::DaliException e) {
93252       {
93253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93254       };
93255     } catch (...) {
93256       {
93257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93258       };
93259     }
93260   }
93261
93262   jresult = *result;
93263   return jresult;
93264 }
93265
93266
93267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93268   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93269   int arg2 ;
93270   unsigned int *arg3 = 0 ;
93271   unsigned int temp3 ;
93272
93273   arg1 = (std::vector< unsigned int > *)jarg1;
93274   arg2 = (int)jarg2;
93275   temp3 = (unsigned int)jarg3;
93276   arg3 = &temp3;
93277   {
93278     try {
93279       try {
93280         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93281       }
93282       catch(std::out_of_range &_e) {
93283         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93284         return ;
93285       }
93286
93287     } catch (std::out_of_range& e) {
93288       {
93289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93290       };
93291     } catch (std::exception& e) {
93292       {
93293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93294       };
93295     } catch (Dali::DaliException e) {
93296       {
93297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93298       };
93299     } catch (...) {
93300       {
93301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93302       };
93303     }
93304   }
93305
93306 }
93307
93308
93309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93310   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93311   std::vector< unsigned int > *arg2 = 0 ;
93312
93313   arg1 = (std::vector< unsigned int > *)jarg1;
93314   arg2 = (std::vector< unsigned int > *)jarg2;
93315   if (!arg2) {
93316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93317     return ;
93318   }
93319   {
93320     try {
93321       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93322     } catch (std::out_of_range& e) {
93323       {
93324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93325       };
93326     } catch (std::exception& e) {
93327       {
93328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93329       };
93330     } catch (Dali::DaliException e) {
93331       {
93332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93333       };
93334     } catch (...) {
93335       {
93336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93337       };
93338     }
93339   }
93340
93341 }
93342
93343
93344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93345   void * jresult ;
93346   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93347   int arg2 ;
93348   int arg3 ;
93349   std::vector< unsigned int > *result = 0 ;
93350
93351   arg1 = (std::vector< unsigned int > *)jarg1;
93352   arg2 = (int)jarg2;
93353   arg3 = (int)jarg3;
93354   {
93355     try {
93356       try {
93357         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93358       }
93359       catch(std::out_of_range &_e) {
93360         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93361         return 0;
93362       }
93363       catch(std::invalid_argument &_e) {
93364         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93365         return 0;
93366       }
93367
93368     } catch (std::out_of_range& e) {
93369       {
93370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93371       };
93372     } catch (std::exception& e) {
93373       {
93374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93375       };
93376     } catch (Dali::DaliException e) {
93377       {
93378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93379       };
93380     } catch (...) {
93381       {
93382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93383       };
93384     }
93385   }
93386
93387   jresult = (void *)result;
93388   return jresult;
93389 }
93390
93391
93392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93393   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93394   int arg2 ;
93395   unsigned int *arg3 = 0 ;
93396   unsigned int temp3 ;
93397
93398   arg1 = (std::vector< unsigned int > *)jarg1;
93399   arg2 = (int)jarg2;
93400   temp3 = (unsigned int)jarg3;
93401   arg3 = &temp3;
93402   {
93403     try {
93404       try {
93405         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93406       }
93407       catch(std::out_of_range &_e) {
93408         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93409         return ;
93410       }
93411
93412     } catch (std::out_of_range& e) {
93413       {
93414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93415       };
93416     } catch (std::exception& e) {
93417       {
93418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93419       };
93420     } catch (Dali::DaliException e) {
93421       {
93422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93423       };
93424     } catch (...) {
93425       {
93426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93427       };
93428     }
93429   }
93430
93431 }
93432
93433
93434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93435   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93436   int arg2 ;
93437   std::vector< unsigned int > *arg3 = 0 ;
93438
93439   arg1 = (std::vector< unsigned int > *)jarg1;
93440   arg2 = (int)jarg2;
93441   arg3 = (std::vector< unsigned int > *)jarg3;
93442   if (!arg3) {
93443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93444     return ;
93445   }
93446   {
93447     try {
93448       try {
93449         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93450       }
93451       catch(std::out_of_range &_e) {
93452         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93453         return ;
93454       }
93455
93456     } catch (std::out_of_range& e) {
93457       {
93458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93459       };
93460     } catch (std::exception& e) {
93461       {
93462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93463       };
93464     } catch (Dali::DaliException e) {
93465       {
93466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93467       };
93468     } catch (...) {
93469       {
93470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93471       };
93472     }
93473   }
93474
93475 }
93476
93477
93478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93479   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93480   int arg2 ;
93481
93482   arg1 = (std::vector< unsigned int > *)jarg1;
93483   arg2 = (int)jarg2;
93484   {
93485     try {
93486       try {
93487         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93488       }
93489       catch(std::out_of_range &_e) {
93490         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93491         return ;
93492       }
93493
93494     } catch (std::out_of_range& e) {
93495       {
93496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93497       };
93498     } catch (std::exception& e) {
93499       {
93500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93501       };
93502     } catch (Dali::DaliException e) {
93503       {
93504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93505       };
93506     } catch (...) {
93507       {
93508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93509       };
93510     }
93511   }
93512
93513 }
93514
93515
93516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93517   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93518   int arg2 ;
93519   int arg3 ;
93520
93521   arg1 = (std::vector< unsigned int > *)jarg1;
93522   arg2 = (int)jarg2;
93523   arg3 = (int)jarg3;
93524   {
93525     try {
93526       try {
93527         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93528       }
93529       catch(std::out_of_range &_e) {
93530         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93531         return ;
93532       }
93533       catch(std::invalid_argument &_e) {
93534         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93535         return ;
93536       }
93537
93538     } catch (std::out_of_range& e) {
93539       {
93540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93541       };
93542     } catch (std::exception& e) {
93543       {
93544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93545       };
93546     } catch (Dali::DaliException e) {
93547       {
93548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93549       };
93550     } catch (...) {
93551       {
93552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93553       };
93554     }
93555   }
93556
93557 }
93558
93559
93560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93561   void * jresult ;
93562   unsigned int *arg1 = 0 ;
93563   int arg2 ;
93564   unsigned int temp1 ;
93565   std::vector< unsigned int > *result = 0 ;
93566
93567   temp1 = (unsigned int)jarg1;
93568   arg1 = &temp1;
93569   arg2 = (int)jarg2;
93570   {
93571     try {
93572       try {
93573         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93574       }
93575       catch(std::out_of_range &_e) {
93576         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93577         return 0;
93578       }
93579
93580     } catch (std::out_of_range& e) {
93581       {
93582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93583       };
93584     } catch (std::exception& e) {
93585       {
93586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93587       };
93588     } catch (Dali::DaliException e) {
93589       {
93590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93591       };
93592     } catch (...) {
93593       {
93594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93595       };
93596     }
93597   }
93598
93599   jresult = (void *)result;
93600   return jresult;
93601 }
93602
93603
93604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93605   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93606
93607   arg1 = (std::vector< unsigned int > *)jarg1;
93608   {
93609     try {
93610       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93611     } catch (std::out_of_range& e) {
93612       {
93613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93614       };
93615     } catch (std::exception& e) {
93616       {
93617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93618       };
93619     } catch (Dali::DaliException e) {
93620       {
93621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93622       };
93623     } catch (...) {
93624       {
93625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93626       };
93627     }
93628   }
93629
93630 }
93631
93632
93633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93634   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93635   int arg2 ;
93636   int arg3 ;
93637
93638   arg1 = (std::vector< unsigned int > *)jarg1;
93639   arg2 = (int)jarg2;
93640   arg3 = (int)jarg3;
93641   {
93642     try {
93643       try {
93644         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93645       }
93646       catch(std::out_of_range &_e) {
93647         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93648         return ;
93649       }
93650       catch(std::invalid_argument &_e) {
93651         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93652         return ;
93653       }
93654
93655     } catch (std::out_of_range& e) {
93656       {
93657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93658       };
93659     } catch (std::exception& e) {
93660       {
93661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93662       };
93663     } catch (Dali::DaliException e) {
93664       {
93665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93666       };
93667     } catch (...) {
93668       {
93669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93670       };
93671     }
93672   }
93673
93674 }
93675
93676
93677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93678   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93679   int arg2 ;
93680   std::vector< unsigned int > *arg3 = 0 ;
93681
93682   arg1 = (std::vector< unsigned int > *)jarg1;
93683   arg2 = (int)jarg2;
93684   arg3 = (std::vector< unsigned int > *)jarg3;
93685   if (!arg3) {
93686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93687     return ;
93688   }
93689   {
93690     try {
93691       try {
93692         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93693       }
93694       catch(std::out_of_range &_e) {
93695         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93696         return ;
93697       }
93698
93699     } catch (std::out_of_range& e) {
93700       {
93701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93702       };
93703     } catch (std::exception& e) {
93704       {
93705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93706       };
93707     } catch (Dali::DaliException e) {
93708       {
93709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93710       };
93711     } catch (...) {
93712       {
93713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93714       };
93715     }
93716   }
93717
93718 }
93719
93720
93721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93722   unsigned int jresult ;
93723   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93724   unsigned int *arg2 = 0 ;
93725   unsigned int temp2 ;
93726   bool result;
93727
93728   arg1 = (std::vector< unsigned int > *)jarg1;
93729   temp2 = (unsigned int)jarg2;
93730   arg2 = &temp2;
93731   {
93732     try {
93733       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93734     } catch (std::out_of_range& e) {
93735       {
93736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93737       };
93738     } catch (std::exception& e) {
93739       {
93740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93741       };
93742     } catch (Dali::DaliException e) {
93743       {
93744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93745       };
93746     } catch (...) {
93747       {
93748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93749       };
93750     }
93751   }
93752
93753   jresult = result;
93754   return jresult;
93755 }
93756
93757
93758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93759   int jresult ;
93760   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93761   unsigned int *arg2 = 0 ;
93762   unsigned int temp2 ;
93763   int result;
93764
93765   arg1 = (std::vector< unsigned int > *)jarg1;
93766   temp2 = (unsigned int)jarg2;
93767   arg2 = &temp2;
93768   {
93769     try {
93770       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93771     } catch (std::out_of_range& e) {
93772       {
93773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93774       };
93775     } catch (std::exception& e) {
93776       {
93777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93778       };
93779     } catch (Dali::DaliException e) {
93780       {
93781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93782       };
93783     } catch (...) {
93784       {
93785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93786       };
93787     }
93788   }
93789
93790   jresult = result;
93791   return jresult;
93792 }
93793
93794
93795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93796   int jresult ;
93797   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93798   unsigned int *arg2 = 0 ;
93799   unsigned int temp2 ;
93800   int result;
93801
93802   arg1 = (std::vector< unsigned int > *)jarg1;
93803   temp2 = (unsigned int)jarg2;
93804   arg2 = &temp2;
93805   {
93806     try {
93807       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93808     } catch (std::out_of_range& e) {
93809       {
93810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93811       };
93812     } catch (std::exception& e) {
93813       {
93814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93815       };
93816     } catch (Dali::DaliException e) {
93817       {
93818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93819       };
93820     } catch (...) {
93821       {
93822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93823       };
93824     }
93825   }
93826
93827   jresult = result;
93828   return jresult;
93829 }
93830
93831
93832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93833   unsigned int jresult ;
93834   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93835   unsigned int *arg2 = 0 ;
93836   unsigned int temp2 ;
93837   bool result;
93838
93839   arg1 = (std::vector< unsigned int > *)jarg1;
93840   temp2 = (unsigned int)jarg2;
93841   arg2 = &temp2;
93842   {
93843     try {
93844       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93845     } catch (std::out_of_range& e) {
93846       {
93847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93848       };
93849     } catch (std::exception& e) {
93850       {
93851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93852       };
93853     } catch (Dali::DaliException e) {
93854       {
93855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93856       };
93857     } catch (...) {
93858       {
93859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93860       };
93861     }
93862   }
93863
93864   jresult = result;
93865   return jresult;
93866 }
93867
93868
93869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93870   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93871
93872   arg1 = (std::vector< unsigned int > *)jarg1;
93873   {
93874     try {
93875       delete arg1;
93876     } catch (std::out_of_range& e) {
93877       {
93878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93879       };
93880     } catch (std::exception& e) {
93881       {
93882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93883       };
93884     } catch (Dali::DaliException e) {
93885       {
93886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93887       };
93888     } catch (...) {
93889       {
93890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93891       };
93892     }
93893   }
93894
93895 }
93896
93897
93898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93899   void * jresult ;
93900   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93901
93902   {
93903     try {
93904       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93905     } catch (std::out_of_range& e) {
93906       {
93907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93908       };
93909     } catch (std::exception& e) {
93910       {
93911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93912       };
93913     } catch (Dali::DaliException e) {
93914       {
93915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93916       };
93917     } catch (...) {
93918       {
93919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93920       };
93921     }
93922   }
93923
93924   jresult = (void *)result;
93925   return jresult;
93926 }
93927
93928
93929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93930   void * jresult ;
93931   unsigned int arg1 ;
93932   Dali::Actor arg2 ;
93933   Dali::Actor *argp2 ;
93934   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93935
93936   arg1 = (unsigned int)jarg1;
93937   argp2 = (Dali::Actor *)jarg2;
93938   if (!argp2) {
93939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93940     return 0;
93941   }
93942   arg2 = *argp2;
93943   {
93944     try {
93945       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93946     } catch (std::out_of_range& e) {
93947       {
93948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93949       };
93950     } catch (std::exception& e) {
93951       {
93952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93953       };
93954     } catch (Dali::DaliException e) {
93955       {
93956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93957       };
93958     } catch (...) {
93959       {
93960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93961       };
93962     }
93963   }
93964
93965   jresult = (void *)result;
93966   return jresult;
93967 }
93968
93969
93970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93971   void * jresult ;
93972   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93973   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93974
93975   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93976   if (!arg1) {
93977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93978     return 0;
93979   }
93980   {
93981     try {
93982       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93983     } catch (std::out_of_range& e) {
93984       {
93985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93986       };
93987     } catch (std::exception& e) {
93988       {
93989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93990       };
93991     } catch (Dali::DaliException e) {
93992       {
93993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93994       };
93995     } catch (...) {
93996       {
93997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93998       };
93999     }
94000   }
94001
94002   jresult = (void *)result;
94003   return jresult;
94004 }
94005
94006
94007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
94008   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94009   unsigned int arg2 ;
94010
94011   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94012   arg2 = (unsigned int)jarg2;
94013   if (arg1) (arg1)->first = arg2;
94014 }
94015
94016
94017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
94018   unsigned int jresult ;
94019   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94020   unsigned int result;
94021
94022   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94023   result = (unsigned int) ((arg1)->first);
94024   jresult = result;
94025   return jresult;
94026 }
94027
94028
94029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
94030   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94031   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
94032
94033   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94034   arg2 = (Dali::Actor *)jarg2;
94035   if (arg1) (arg1)->second = *arg2;
94036 }
94037
94038
94039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
94040   void * jresult ;
94041   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94042   Dali::Actor *result = 0 ;
94043
94044   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94045   result = (Dali::Actor *)& ((arg1)->second);
94046   jresult = (void *)result;
94047   return jresult;
94048 }
94049
94050
94051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
94052   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94053
94054   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94055   {
94056     try {
94057       delete arg1;
94058     } catch (std::out_of_range& e) {
94059       {
94060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94061       };
94062     } catch (std::exception& e) {
94063       {
94064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94065       };
94066     } catch (Dali::DaliException e) {
94067       {
94068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94069       };
94070     } catch (...) {
94071       {
94072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94073       };
94074     }
94075   }
94076
94077 }
94078
94079
94080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
94081   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94082
94083   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94084   {
94085     try {
94086       (arg1)->clear();
94087     } catch (std::out_of_range& e) {
94088       {
94089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94090       };
94091     } catch (std::exception& e) {
94092       {
94093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94094       };
94095     } catch (Dali::DaliException e) {
94096       {
94097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94098       };
94099     } catch (...) {
94100       {
94101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94102       };
94103     }
94104   }
94105
94106 }
94107
94108
94109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
94110   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94111   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
94112
94113   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94114   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
94115   if (!arg2) {
94116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94117     return ;
94118   }
94119   {
94120     try {
94121       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
94122     } catch (std::out_of_range& e) {
94123       {
94124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94125       };
94126     } catch (std::exception& e) {
94127       {
94128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94129       };
94130     } catch (Dali::DaliException e) {
94131       {
94132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94133       };
94134     } catch (...) {
94135       {
94136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94137       };
94138     }
94139   }
94140
94141 }
94142
94143
94144 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94145   unsigned long jresult ;
94146   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94147   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94148
94149   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94150   {
94151     try {
94152       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94153     } catch (std::out_of_range& e) {
94154       {
94155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94156       };
94157     } catch (std::exception& e) {
94158       {
94159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94160       };
94161     } catch (Dali::DaliException e) {
94162       {
94163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94164       };
94165     } catch (...) {
94166       {
94167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94168       };
94169     }
94170   }
94171
94172   jresult = (unsigned long)result;
94173   return jresult;
94174 }
94175
94176
94177 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94178   unsigned long jresult ;
94179   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94180   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94181
94182   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94183   {
94184     try {
94185       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
94186     } catch (std::out_of_range& e) {
94187       {
94188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94189       };
94190     } catch (std::exception& e) {
94191       {
94192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94193       };
94194     } catch (Dali::DaliException e) {
94195       {
94196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94197       };
94198     } catch (...) {
94199       {
94200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94201       };
94202     }
94203   }
94204
94205   jresult = (unsigned long)result;
94206   return jresult;
94207 }
94208
94209
94210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
94211   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94212   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
94213
94214   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94215   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94216   {
94217     try {
94218       (arg1)->reserve(arg2);
94219     } catch (std::out_of_range& e) {
94220       {
94221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94222       };
94223     } catch (std::exception& e) {
94224       {
94225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94226       };
94227     } catch (Dali::DaliException e) {
94228       {
94229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94230       };
94231     } catch (...) {
94232       {
94233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94234       };
94235     }
94236   }
94237
94238 }
94239
94240
94241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94242   void * jresult ;
94243   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94244
94245   {
94246     try {
94247       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94248     } catch (std::out_of_range& e) {
94249       {
94250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94251       };
94252     } catch (std::exception& e) {
94253       {
94254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94255       };
94256     } catch (Dali::DaliException e) {
94257       {
94258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94259       };
94260     } catch (...) {
94261       {
94262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94263       };
94264     }
94265   }
94266
94267   jresult = (void *)result;
94268   return jresult;
94269 }
94270
94271
94272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94273   void * jresult ;
94274   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94275   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94276
94277   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94278   if (!arg1) {
94279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94280     return 0;
94281   }
94282   {
94283     try {
94284       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);
94285     } catch (std::out_of_range& e) {
94286       {
94287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94288       };
94289     } catch (std::exception& e) {
94290       {
94291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94292       };
94293     } catch (Dali::DaliException e) {
94294       {
94295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94296       };
94297     } catch (...) {
94298       {
94299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94300       };
94301     }
94302   }
94303
94304   jresult = (void *)result;
94305   return jresult;
94306 }
94307
94308
94309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
94310   void * jresult ;
94311   int arg1 ;
94312   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94313
94314   arg1 = (int)jarg1;
94315   {
94316     try {
94317       try {
94318         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);
94319       }
94320       catch(std::out_of_range &_e) {
94321         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94322         return 0;
94323       }
94324
94325     } catch (std::out_of_range& e) {
94326       {
94327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94328       };
94329     } catch (std::exception& e) {
94330       {
94331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94332       };
94333     } catch (Dali::DaliException e) {
94334       {
94335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94336       };
94337     } catch (...) {
94338       {
94339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94340       };
94341     }
94342   }
94343
94344   jresult = (void *)result;
94345   return jresult;
94346 }
94347
94348
94349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94350   void * jresult ;
94351   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94352   int arg2 ;
94353   std::pair< unsigned int,Dali::Actor > result;
94354
94355   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94356   arg2 = (int)jarg2;
94357   {
94358     try {
94359       try {
94360         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94361       }
94362       catch(std::out_of_range &_e) {
94363         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94364         return 0;
94365       }
94366
94367     } catch (std::out_of_range& e) {
94368       {
94369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94370       };
94371     } catch (std::exception& e) {
94372       {
94373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94374       };
94375     } catch (Dali::DaliException e) {
94376       {
94377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94378       };
94379     } catch (...) {
94380       {
94381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94382       };
94383     }
94384   }
94385
94386   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94387   return jresult;
94388 }
94389
94390
94391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94392   void * jresult ;
94393   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94394   int arg2 ;
94395   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94396
94397   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94398   arg2 = (int)jarg2;
94399   {
94400     try {
94401       try {
94402         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94403       }
94404       catch(std::out_of_range &_e) {
94405         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94406         return 0;
94407       }
94408
94409     } catch (std::out_of_range& e) {
94410       {
94411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94412       };
94413     } catch (std::exception& e) {
94414       {
94415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94416       };
94417     } catch (Dali::DaliException e) {
94418       {
94419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94420       };
94421     } catch (...) {
94422       {
94423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94424       };
94425     }
94426   }
94427
94428   jresult = (void *)result;
94429   return jresult;
94430 }
94431
94432
94433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94434   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94435   int arg2 ;
94436   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94437
94438   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94439   arg2 = (int)jarg2;
94440   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94441   if (!arg3) {
94442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94443     return ;
94444   }
94445   {
94446     try {
94447       try {
94448         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);
94449       }
94450       catch(std::out_of_range &_e) {
94451         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94452         return ;
94453       }
94454
94455     } catch (std::out_of_range& e) {
94456       {
94457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94458       };
94459     } catch (std::exception& e) {
94460       {
94461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94462       };
94463     } catch (Dali::DaliException e) {
94464       {
94465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94466       };
94467     } catch (...) {
94468       {
94469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94470       };
94471     }
94472   }
94473
94474 }
94475
94476
94477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94478   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94479   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94480
94481   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94482   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94483   if (!arg2) {
94484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94485     return ;
94486   }
94487   {
94488     try {
94489       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);
94490     } catch (std::out_of_range& e) {
94491       {
94492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94493       };
94494     } catch (std::exception& e) {
94495       {
94496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94497       };
94498     } catch (Dali::DaliException e) {
94499       {
94500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94501       };
94502     } catch (...) {
94503       {
94504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94505       };
94506     }
94507   }
94508
94509 }
94510
94511
94512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94513   void * jresult ;
94514   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94515   int arg2 ;
94516   int arg3 ;
94517   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94518
94519   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94520   arg2 = (int)jarg2;
94521   arg3 = (int)jarg3;
94522   {
94523     try {
94524       try {
94525         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);
94526       }
94527       catch(std::out_of_range &_e) {
94528         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94529         return 0;
94530       }
94531       catch(std::invalid_argument &_e) {
94532         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94533         return 0;
94534       }
94535
94536     } catch (std::out_of_range& e) {
94537       {
94538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94539       };
94540     } catch (std::exception& e) {
94541       {
94542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94543       };
94544     } catch (Dali::DaliException e) {
94545       {
94546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94547       };
94548     } catch (...) {
94549       {
94550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94551       };
94552     }
94553   }
94554
94555   jresult = (void *)result;
94556   return jresult;
94557 }
94558
94559
94560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94561   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94562   int arg2 ;
94563   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94564
94565   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94566   arg2 = (int)jarg2;
94567   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94568   if (!arg3) {
94569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94570     return ;
94571   }
94572   {
94573     try {
94574       try {
94575         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);
94576       }
94577       catch(std::out_of_range &_e) {
94578         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94579         return ;
94580       }
94581
94582     } catch (std::out_of_range& e) {
94583       {
94584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94585       };
94586     } catch (std::exception& e) {
94587       {
94588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94589       };
94590     } catch (Dali::DaliException e) {
94591       {
94592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94593       };
94594     } catch (...) {
94595       {
94596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94597       };
94598     }
94599   }
94600
94601 }
94602
94603
94604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94605   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94606   int arg2 ;
94607   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94608
94609   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94610   arg2 = (int)jarg2;
94611   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94612   if (!arg3) {
94613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94614     return ;
94615   }
94616   {
94617     try {
94618       try {
94619         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);
94620       }
94621       catch(std::out_of_range &_e) {
94622         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94623         return ;
94624       }
94625
94626     } catch (std::out_of_range& e) {
94627       {
94628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94629       };
94630     } catch (std::exception& e) {
94631       {
94632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94633       };
94634     } catch (Dali::DaliException e) {
94635       {
94636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94637       };
94638     } catch (...) {
94639       {
94640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94641       };
94642     }
94643   }
94644
94645 }
94646
94647
94648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94649   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94650   int arg2 ;
94651
94652   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94653   arg2 = (int)jarg2;
94654   {
94655     try {
94656       try {
94657         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94658       }
94659       catch(std::out_of_range &_e) {
94660         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94661         return ;
94662       }
94663
94664     } catch (std::out_of_range& e) {
94665       {
94666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94667       };
94668     } catch (std::exception& e) {
94669       {
94670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94671       };
94672     } catch (Dali::DaliException e) {
94673       {
94674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94675       };
94676     } catch (...) {
94677       {
94678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94679       };
94680     }
94681   }
94682
94683 }
94684
94685
94686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94687   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94688   int arg2 ;
94689   int arg3 ;
94690
94691   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94692   arg2 = (int)jarg2;
94693   arg3 = (int)jarg3;
94694   {
94695     try {
94696       try {
94697         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94698       }
94699       catch(std::out_of_range &_e) {
94700         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94701         return ;
94702       }
94703       catch(std::invalid_argument &_e) {
94704         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94705         return ;
94706       }
94707
94708     } catch (std::out_of_range& e) {
94709       {
94710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94711       };
94712     } catch (std::exception& e) {
94713       {
94714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94715       };
94716     } catch (Dali::DaliException e) {
94717       {
94718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94719       };
94720     } catch (...) {
94721       {
94722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94723       };
94724     }
94725   }
94726
94727 }
94728
94729
94730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94731   void * jresult ;
94732   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94733   int arg2 ;
94734   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94735
94736   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94737   if (!arg1) {
94738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94739     return 0;
94740   }
94741   arg2 = (int)jarg2;
94742   {
94743     try {
94744       try {
94745         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);
94746       }
94747       catch(std::out_of_range &_e) {
94748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94749         return 0;
94750       }
94751
94752     } catch (std::out_of_range& e) {
94753       {
94754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94755       };
94756     } catch (std::exception& e) {
94757       {
94758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94759       };
94760     } catch (Dali::DaliException e) {
94761       {
94762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94763       };
94764     } catch (...) {
94765       {
94766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94767       };
94768     }
94769   }
94770
94771   jresult = (void *)result;
94772   return jresult;
94773 }
94774
94775
94776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94777   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94778
94779   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94780   {
94781     try {
94782       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94783     } catch (std::out_of_range& e) {
94784       {
94785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94786       };
94787     } catch (std::exception& e) {
94788       {
94789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94790       };
94791     } catch (Dali::DaliException e) {
94792       {
94793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94794       };
94795     } catch (...) {
94796       {
94797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94798       };
94799     }
94800   }
94801
94802 }
94803
94804
94805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94806   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94807   int arg2 ;
94808   int arg3 ;
94809
94810   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94811   arg2 = (int)jarg2;
94812   arg3 = (int)jarg3;
94813   {
94814     try {
94815       try {
94816         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94817       }
94818       catch(std::out_of_range &_e) {
94819         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94820         return ;
94821       }
94822       catch(std::invalid_argument &_e) {
94823         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94824         return ;
94825       }
94826
94827     } catch (std::out_of_range& e) {
94828       {
94829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94830       };
94831     } catch (std::exception& e) {
94832       {
94833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94834       };
94835     } catch (Dali::DaliException e) {
94836       {
94837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94838       };
94839     } catch (...) {
94840       {
94841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94842       };
94843     }
94844   }
94845
94846 }
94847
94848
94849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94850   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94851   int arg2 ;
94852   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94853
94854   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94855   arg2 = (int)jarg2;
94856   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94857   if (!arg3) {
94858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94859     return ;
94860   }
94861   {
94862     try {
94863       try {
94864         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);
94865       }
94866       catch(std::out_of_range &_e) {
94867         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94868         return ;
94869       }
94870
94871     } catch (std::out_of_range& e) {
94872       {
94873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94874       };
94875     } catch (std::exception& e) {
94876       {
94877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94878       };
94879     } catch (Dali::DaliException e) {
94880       {
94881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94882       };
94883     } catch (...) {
94884       {
94885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94886       };
94887     }
94888   }
94889
94890 }
94891
94892
94893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94894   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94895
94896   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94897   {
94898     try {
94899       delete arg1;
94900     } catch (std::out_of_range& e) {
94901       {
94902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94903       };
94904     } catch (std::exception& e) {
94905       {
94906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94907       };
94908     } catch (Dali::DaliException e) {
94909       {
94910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94911       };
94912     } catch (...) {
94913       {
94914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94915       };
94916     }
94917   }
94918
94919 }
94920
94921
94922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94923   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94924
94925   arg1 = (std::vector< Dali::Actor > *)jarg1;
94926   {
94927     try {
94928       (arg1)->clear();
94929     } catch (std::out_of_range& e) {
94930       {
94931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94932       };
94933     } catch (std::exception& e) {
94934       {
94935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94936       };
94937     } catch (Dali::DaliException e) {
94938       {
94939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94940       };
94941     } catch (...) {
94942       {
94943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94944       };
94945     }
94946   }
94947
94948 }
94949
94950
94951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94952   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94953   Dali::Actor *arg2 = 0 ;
94954
94955   arg1 = (std::vector< Dali::Actor > *)jarg1;
94956   arg2 = (Dali::Actor *)jarg2;
94957   if (!arg2) {
94958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94959     return ;
94960   }
94961   {
94962     try {
94963       (arg1)->push_back((Dali::Actor const &)*arg2);
94964     } catch (std::out_of_range& e) {
94965       {
94966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94967       };
94968     } catch (std::exception& e) {
94969       {
94970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94971       };
94972     } catch (Dali::DaliException e) {
94973       {
94974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94975       };
94976     } catch (...) {
94977       {
94978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94979       };
94980     }
94981   }
94982
94983 }
94984
94985
94986 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94987   unsigned long jresult ;
94988   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94989   std::vector< Dali::Actor >::size_type result;
94990
94991   arg1 = (std::vector< Dali::Actor > *)jarg1;
94992   {
94993     try {
94994       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94995     } catch (std::out_of_range& e) {
94996       {
94997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94998       };
94999     } catch (std::exception& e) {
95000       {
95001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95002       };
95003     } catch (Dali::DaliException e) {
95004       {
95005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95006       };
95007     } catch (...) {
95008       {
95009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95010       };
95011     }
95012   }
95013
95014   jresult = (unsigned long)result;
95015   return jresult;
95016 }
95017
95018
95019 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
95020   unsigned long jresult ;
95021   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95022   std::vector< Dali::Actor >::size_type result;
95023
95024   arg1 = (std::vector< Dali::Actor > *)jarg1;
95025   {
95026     try {
95027       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
95028     } catch (std::out_of_range& e) {
95029       {
95030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95031       };
95032     } catch (std::exception& e) {
95033       {
95034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95035       };
95036     } catch (Dali::DaliException e) {
95037       {
95038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95039       };
95040     } catch (...) {
95041       {
95042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95043       };
95044     }
95045   }
95046
95047   jresult = (unsigned long)result;
95048   return jresult;
95049 }
95050
95051
95052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
95053   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95054   std::vector< Dali::Actor >::size_type arg2 ;
95055
95056   arg1 = (std::vector< Dali::Actor > *)jarg1;
95057   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
95058   {
95059     try {
95060       (arg1)->reserve(arg2);
95061     } catch (std::out_of_range& e) {
95062       {
95063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95064       };
95065     } catch (std::exception& e) {
95066       {
95067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95068       };
95069     } catch (Dali::DaliException e) {
95070       {
95071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95072       };
95073     } catch (...) {
95074       {
95075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95076       };
95077     }
95078   }
95079
95080 }
95081
95082
95083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
95084   void * jresult ;
95085   std::vector< Dali::Actor > *result = 0 ;
95086
95087   {
95088     try {
95089       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
95090     } catch (std::out_of_range& e) {
95091       {
95092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95093       };
95094     } catch (std::exception& e) {
95095       {
95096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95097       };
95098     } catch (Dali::DaliException e) {
95099       {
95100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95101       };
95102     } catch (...) {
95103       {
95104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95105       };
95106     }
95107   }
95108
95109   jresult = (void *)result;
95110   return jresult;
95111 }
95112
95113
95114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
95115   void * jresult ;
95116   std::vector< Dali::Actor > *arg1 = 0 ;
95117   std::vector< Dali::Actor > *result = 0 ;
95118
95119   arg1 = (std::vector< Dali::Actor > *)jarg1;
95120   if (!arg1) {
95121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95122     return 0;
95123   }
95124   {
95125     try {
95126       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
95127     } catch (std::out_of_range& e) {
95128       {
95129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95130       };
95131     } catch (std::exception& e) {
95132       {
95133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95134       };
95135     } catch (Dali::DaliException e) {
95136       {
95137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95138       };
95139     } catch (...) {
95140       {
95141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95142       };
95143     }
95144   }
95145
95146   jresult = (void *)result;
95147   return jresult;
95148 }
95149
95150
95151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
95152   void * jresult ;
95153   int arg1 ;
95154   std::vector< Dali::Actor > *result = 0 ;
95155
95156   arg1 = (int)jarg1;
95157   {
95158     try {
95159       try {
95160         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95161       }
95162       catch(std::out_of_range &_e) {
95163         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95164         return 0;
95165       }
95166
95167     } catch (std::out_of_range& e) {
95168       {
95169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95170       };
95171     } catch (std::exception& e) {
95172       {
95173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95174       };
95175     } catch (Dali::DaliException e) {
95176       {
95177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95178       };
95179     } catch (...) {
95180       {
95181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95182       };
95183     }
95184   }
95185
95186   jresult = (void *)result;
95187   return jresult;
95188 }
95189
95190
95191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95192   void * jresult ;
95193   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95194   int arg2 ;
95195   Dali::Actor result;
95196
95197   arg1 = (std::vector< Dali::Actor > *)jarg1;
95198   arg2 = (int)jarg2;
95199   {
95200     try {
95201       try {
95202         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95203       }
95204       catch(std::out_of_range &_e) {
95205         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95206         return 0;
95207       }
95208
95209     } catch (std::out_of_range& e) {
95210       {
95211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95212       };
95213     } catch (std::exception& e) {
95214       {
95215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95216       };
95217     } catch (Dali::DaliException e) {
95218       {
95219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95220       };
95221     } catch (...) {
95222       {
95223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95224       };
95225     }
95226   }
95227
95228   jresult = new Dali::Actor((const Dali::Actor &)result);
95229   return jresult;
95230 }
95231
95232
95233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95234   void * jresult ;
95235   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95236   int arg2 ;
95237   Dali::Actor *result = 0 ;
95238
95239   arg1 = (std::vector< Dali::Actor > *)jarg1;
95240   arg2 = (int)jarg2;
95241   {
95242     try {
95243       try {
95244         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95245       }
95246       catch(std::out_of_range &_e) {
95247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95248         return 0;
95249       }
95250
95251     } catch (std::out_of_range& e) {
95252       {
95253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95254       };
95255     } catch (std::exception& e) {
95256       {
95257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95258       };
95259     } catch (Dali::DaliException e) {
95260       {
95261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95262       };
95263     } catch (...) {
95264       {
95265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95266       };
95267     }
95268   }
95269
95270   jresult = (void *)result;
95271   return jresult;
95272 }
95273
95274
95275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95276   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95277   int arg2 ;
95278   Dali::Actor *arg3 = 0 ;
95279
95280   arg1 = (std::vector< Dali::Actor > *)jarg1;
95281   arg2 = (int)jarg2;
95282   arg3 = (Dali::Actor *)jarg3;
95283   if (!arg3) {
95284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95285     return ;
95286   }
95287   {
95288     try {
95289       try {
95290         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95291       }
95292       catch(std::out_of_range &_e) {
95293         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95294         return ;
95295       }
95296
95297     } catch (std::out_of_range& e) {
95298       {
95299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95300       };
95301     } catch (std::exception& e) {
95302       {
95303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95304       };
95305     } catch (Dali::DaliException e) {
95306       {
95307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95308       };
95309     } catch (...) {
95310       {
95311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95312       };
95313     }
95314   }
95315
95316 }
95317
95318
95319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95320   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95321   std::vector< Dali::Actor > *arg2 = 0 ;
95322
95323   arg1 = (std::vector< Dali::Actor > *)jarg1;
95324   arg2 = (std::vector< Dali::Actor > *)jarg2;
95325   if (!arg2) {
95326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95327     return ;
95328   }
95329   {
95330     try {
95331       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95332     } catch (std::out_of_range& e) {
95333       {
95334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95335       };
95336     } catch (std::exception& e) {
95337       {
95338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95339       };
95340     } catch (Dali::DaliException e) {
95341       {
95342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95343       };
95344     } catch (...) {
95345       {
95346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95347       };
95348     }
95349   }
95350
95351 }
95352
95353
95354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95355   void * jresult ;
95356   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95357   int arg2 ;
95358   int arg3 ;
95359   std::vector< Dali::Actor > *result = 0 ;
95360
95361   arg1 = (std::vector< Dali::Actor > *)jarg1;
95362   arg2 = (int)jarg2;
95363   arg3 = (int)jarg3;
95364   {
95365     try {
95366       try {
95367         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95368       }
95369       catch(std::out_of_range &_e) {
95370         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95371         return 0;
95372       }
95373       catch(std::invalid_argument &_e) {
95374         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95375         return 0;
95376       }
95377
95378     } catch (std::out_of_range& e) {
95379       {
95380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95381       };
95382     } catch (std::exception& e) {
95383       {
95384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95385       };
95386     } catch (Dali::DaliException e) {
95387       {
95388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95389       };
95390     } catch (...) {
95391       {
95392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95393       };
95394     }
95395   }
95396
95397   jresult = (void *)result;
95398   return jresult;
95399 }
95400
95401
95402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95403   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95404   int arg2 ;
95405   Dali::Actor *arg3 = 0 ;
95406
95407   arg1 = (std::vector< Dali::Actor > *)jarg1;
95408   arg2 = (int)jarg2;
95409   arg3 = (Dali::Actor *)jarg3;
95410   if (!arg3) {
95411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95412     return ;
95413   }
95414   {
95415     try {
95416       try {
95417         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95418       }
95419       catch(std::out_of_range &_e) {
95420         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95421         return ;
95422       }
95423
95424     } catch (std::out_of_range& e) {
95425       {
95426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95427       };
95428     } catch (std::exception& e) {
95429       {
95430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95431       };
95432     } catch (Dali::DaliException e) {
95433       {
95434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95435       };
95436     } catch (...) {
95437       {
95438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95439       };
95440     }
95441   }
95442
95443 }
95444
95445
95446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95447   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95448   int arg2 ;
95449   std::vector< Dali::Actor > *arg3 = 0 ;
95450
95451   arg1 = (std::vector< Dali::Actor > *)jarg1;
95452   arg2 = (int)jarg2;
95453   arg3 = (std::vector< Dali::Actor > *)jarg3;
95454   if (!arg3) {
95455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95456     return ;
95457   }
95458   {
95459     try {
95460       try {
95461         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95462       }
95463       catch(std::out_of_range &_e) {
95464         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95465         return ;
95466       }
95467
95468     } catch (std::out_of_range& e) {
95469       {
95470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95471       };
95472     } catch (std::exception& e) {
95473       {
95474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95475       };
95476     } catch (Dali::DaliException e) {
95477       {
95478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95479       };
95480     } catch (...) {
95481       {
95482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95483       };
95484     }
95485   }
95486
95487 }
95488
95489
95490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95491   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95492   int arg2 ;
95493
95494   arg1 = (std::vector< Dali::Actor > *)jarg1;
95495   arg2 = (int)jarg2;
95496   {
95497     try {
95498       try {
95499         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95500       }
95501       catch(std::out_of_range &_e) {
95502         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95503         return ;
95504       }
95505
95506     } catch (std::out_of_range& e) {
95507       {
95508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95509       };
95510     } catch (std::exception& e) {
95511       {
95512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95513       };
95514     } catch (Dali::DaliException e) {
95515       {
95516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95517       };
95518     } catch (...) {
95519       {
95520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95521       };
95522     }
95523   }
95524
95525 }
95526
95527
95528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95529   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95530   int arg2 ;
95531   int arg3 ;
95532
95533   arg1 = (std::vector< Dali::Actor > *)jarg1;
95534   arg2 = (int)jarg2;
95535   arg3 = (int)jarg3;
95536   {
95537     try {
95538       try {
95539         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95540       }
95541       catch(std::out_of_range &_e) {
95542         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95543         return ;
95544       }
95545       catch(std::invalid_argument &_e) {
95546         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95547         return ;
95548       }
95549
95550     } catch (std::out_of_range& e) {
95551       {
95552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95553       };
95554     } catch (std::exception& e) {
95555       {
95556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95557       };
95558     } catch (Dali::DaliException e) {
95559       {
95560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95561       };
95562     } catch (...) {
95563       {
95564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95565       };
95566     }
95567   }
95568
95569 }
95570
95571
95572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95573   void * jresult ;
95574   Dali::Actor *arg1 = 0 ;
95575   int arg2 ;
95576   std::vector< Dali::Actor > *result = 0 ;
95577
95578   arg1 = (Dali::Actor *)jarg1;
95579   if (!arg1) {
95580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95581     return 0;
95582   }
95583   arg2 = (int)jarg2;
95584   {
95585     try {
95586       try {
95587         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95588       }
95589       catch(std::out_of_range &_e) {
95590         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95591         return 0;
95592       }
95593
95594     } catch (std::out_of_range& e) {
95595       {
95596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95597       };
95598     } catch (std::exception& e) {
95599       {
95600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95601       };
95602     } catch (Dali::DaliException e) {
95603       {
95604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95605       };
95606     } catch (...) {
95607       {
95608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95609       };
95610     }
95611   }
95612
95613   jresult = (void *)result;
95614   return jresult;
95615 }
95616
95617
95618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95619   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95620
95621   arg1 = (std::vector< Dali::Actor > *)jarg1;
95622   {
95623     try {
95624       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95625     } catch (std::out_of_range& e) {
95626       {
95627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95628       };
95629     } catch (std::exception& e) {
95630       {
95631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95632       };
95633     } catch (Dali::DaliException e) {
95634       {
95635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95636       };
95637     } catch (...) {
95638       {
95639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95640       };
95641     }
95642   }
95643
95644 }
95645
95646
95647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95648   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95649   int arg2 ;
95650   int arg3 ;
95651
95652   arg1 = (std::vector< Dali::Actor > *)jarg1;
95653   arg2 = (int)jarg2;
95654   arg3 = (int)jarg3;
95655   {
95656     try {
95657       try {
95658         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95659       }
95660       catch(std::out_of_range &_e) {
95661         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95662         return ;
95663       }
95664       catch(std::invalid_argument &_e) {
95665         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95666         return ;
95667       }
95668
95669     } catch (std::out_of_range& e) {
95670       {
95671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95672       };
95673     } catch (std::exception& e) {
95674       {
95675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95676       };
95677     } catch (Dali::DaliException e) {
95678       {
95679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95680       };
95681     } catch (...) {
95682       {
95683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95684       };
95685     }
95686   }
95687
95688 }
95689
95690
95691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95692   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95693   int arg2 ;
95694   std::vector< Dali::Actor > *arg3 = 0 ;
95695
95696   arg1 = (std::vector< Dali::Actor > *)jarg1;
95697   arg2 = (int)jarg2;
95698   arg3 = (std::vector< Dali::Actor > *)jarg3;
95699   if (!arg3) {
95700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95701     return ;
95702   }
95703   {
95704     try {
95705       try {
95706         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95707       }
95708       catch(std::out_of_range &_e) {
95709         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95710         return ;
95711       }
95712
95713     } catch (std::out_of_range& e) {
95714       {
95715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95716       };
95717     } catch (std::exception& e) {
95718       {
95719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95720       };
95721     } catch (Dali::DaliException e) {
95722       {
95723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95724       };
95725     } catch (...) {
95726       {
95727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95728       };
95729     }
95730   }
95731
95732 }
95733
95734
95735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95736   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95737
95738   arg1 = (std::vector< Dali::Actor > *)jarg1;
95739   {
95740     try {
95741       delete arg1;
95742     } catch (std::out_of_range& e) {
95743       {
95744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95745       };
95746     } catch (std::exception& e) {
95747       {
95748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95749       };
95750     } catch (Dali::DaliException e) {
95751       {
95752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95753       };
95754     } catch (...) {
95755       {
95756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95757       };
95758     }
95759   }
95760
95761 }
95762
95763
95764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95765   unsigned int jresult ;
95766   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95767   bool result;
95768
95769   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95770   {
95771     try {
95772       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95773     } catch (std::out_of_range& e) {
95774       {
95775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95776       };
95777     } catch (std::exception& e) {
95778       {
95779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95780       };
95781     } catch (Dali::DaliException e) {
95782       {
95783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95784       };
95785     } catch (...) {
95786       {
95787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95788       };
95789     }
95790   }
95791
95792   jresult = result;
95793   return jresult;
95794 }
95795
95796
95797 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95798   unsigned long jresult ;
95799   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95800   std::size_t result;
95801
95802   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95803   {
95804     try {
95805       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95806     } catch (std::out_of_range& e) {
95807       {
95808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95809       };
95810     } catch (std::exception& e) {
95811       {
95812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95813       };
95814     } catch (Dali::DaliException e) {
95815       {
95816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95817       };
95818     } catch (...) {
95819       {
95820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95821       };
95822     }
95823   }
95824
95825   jresult = (unsigned long)result;
95826   return jresult;
95827 }
95828
95829
95830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95831   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95832   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95833
95834   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95835   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95836   {
95837     try {
95838       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95839     } catch (std::out_of_range& e) {
95840       {
95841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95842       };
95843     } catch (std::exception& e) {
95844       {
95845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95846       };
95847     } catch (Dali::DaliException e) {
95848       {
95849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95850       };
95851     } catch (...) {
95852       {
95853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95854       };
95855     }
95856   }
95857
95858 }
95859
95860
95861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95862   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95863   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95864
95865   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95866   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95867   {
95868     try {
95869       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95870     } catch (std::out_of_range& e) {
95871       {
95872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95873       };
95874     } catch (std::exception& e) {
95875       {
95876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95877       };
95878     } catch (Dali::DaliException e) {
95879       {
95880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95881       };
95882     } catch (...) {
95883       {
95884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95885       };
95886     }
95887   }
95888
95889 }
95890
95891
95892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95893   unsigned int jresult ;
95894   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95895   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95896   bool result;
95897
95898   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95899   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95900   if (!arg2) {
95901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95902     return 0;
95903   }
95904   {
95905     try {
95906       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95907     } catch (std::out_of_range& e) {
95908       {
95909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95910       };
95911     } catch (std::exception& e) {
95912       {
95913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95914       };
95915     } catch (Dali::DaliException e) {
95916       {
95917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95918       };
95919     } catch (...) {
95920       {
95921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95922       };
95923     }
95924   }
95925
95926   jresult = result;
95927   return jresult;
95928 }
95929
95930
95931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95932   void * jresult ;
95933   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95934
95935   {
95936     try {
95937       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95938     } catch (std::out_of_range& e) {
95939       {
95940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95941       };
95942     } catch (std::exception& e) {
95943       {
95944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95945       };
95946     } catch (Dali::DaliException e) {
95947       {
95948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95949       };
95950     } catch (...) {
95951       {
95952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95953       };
95954     }
95955   }
95956
95957   jresult = (void *)result;
95958   return jresult;
95959 }
95960
95961
95962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95963   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95964
95965   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95966   {
95967     try {
95968       delete arg1;
95969     } catch (std::out_of_range& e) {
95970       {
95971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95972       };
95973     } catch (std::exception& e) {
95974       {
95975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95976       };
95977     } catch (Dali::DaliException e) {
95978       {
95979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95980       };
95981     } catch (...) {
95982       {
95983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95984       };
95985     }
95986   }
95987
95988 }
95989
95990
95991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95992   unsigned int jresult ;
95993   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95994   bool result;
95995
95996   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95997   {
95998     try {
95999       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);
96000     } catch (std::out_of_range& e) {
96001       {
96002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96003       };
96004     } catch (std::exception& e) {
96005       {
96006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96007       };
96008     } catch (Dali::DaliException e) {
96009       {
96010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96011       };
96012     } catch (...) {
96013       {
96014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96015       };
96016     }
96017   }
96018
96019   jresult = result;
96020   return jresult;
96021 }
96022
96023
96024 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
96025   unsigned long jresult ;
96026   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96027   std::size_t result;
96028
96029   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96030   {
96031     try {
96032       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);
96033     } catch (std::out_of_range& e) {
96034       {
96035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96036       };
96037     } catch (std::exception& e) {
96038       {
96039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96040       };
96041     } catch (Dali::DaliException e) {
96042       {
96043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96044       };
96045     } catch (...) {
96046       {
96047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96048       };
96049     }
96050   }
96051
96052   jresult = (unsigned long)result;
96053   return jresult;
96054 }
96055
96056
96057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
96058   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96059   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96060
96061   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96062   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96063   {
96064     try {
96065       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
96066     } catch (std::out_of_range& e) {
96067       {
96068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96069       };
96070     } catch (std::exception& e) {
96071       {
96072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96073       };
96074     } catch (Dali::DaliException e) {
96075       {
96076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96077       };
96078     } catch (...) {
96079       {
96080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96081       };
96082     }
96083   }
96084
96085 }
96086
96087
96088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
96089   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96090   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96091
96092   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96093   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96094   {
96095     try {
96096       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
96097     } catch (std::out_of_range& e) {
96098       {
96099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96100       };
96101     } catch (std::exception& e) {
96102       {
96103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96104       };
96105     } catch (Dali::DaliException e) {
96106       {
96107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96108       };
96109     } catch (...) {
96110       {
96111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96112       };
96113     }
96114   }
96115
96116 }
96117
96118
96119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96120   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96121   Dali::Actor arg2 ;
96122   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
96123   Dali::Actor *argp2 ;
96124
96125   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96126   argp2 = (Dali::Actor *)jarg2;
96127   if (!argp2) {
96128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96129     return ;
96130   }
96131   arg2 = *argp2;
96132   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
96133   {
96134     try {
96135       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
96136     } catch (std::out_of_range& e) {
96137       {
96138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96139       };
96140     } catch (std::exception& e) {
96141       {
96142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96143       };
96144     } catch (Dali::DaliException e) {
96145       {
96146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96147       };
96148     } catch (...) {
96149       {
96150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96151       };
96152     }
96153   }
96154
96155 }
96156
96157
96158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96159   void * jresult ;
96160   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96161
96162   {
96163     try {
96164       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96165     } catch (std::out_of_range& e) {
96166       {
96167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96168       };
96169     } catch (std::exception& e) {
96170       {
96171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96172       };
96173     } catch (Dali::DaliException e) {
96174       {
96175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96176       };
96177     } catch (...) {
96178       {
96179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96180       };
96181     }
96182   }
96183
96184   jresult = (void *)result;
96185   return jresult;
96186 }
96187
96188
96189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96190   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96191
96192   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96193   {
96194     try {
96195       delete arg1;
96196     } catch (std::out_of_range& e) {
96197       {
96198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96199       };
96200     } catch (std::exception& e) {
96201       {
96202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96203       };
96204     } catch (Dali::DaliException e) {
96205       {
96206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96207       };
96208     } catch (...) {
96209       {
96210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96211       };
96212     }
96213   }
96214
96215 }
96216
96217
96218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96219   unsigned int jresult ;
96220   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96221   bool result;
96222
96223   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96224   {
96225     try {
96226       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96227     } catch (std::out_of_range& e) {
96228       {
96229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96230       };
96231     } catch (std::exception& e) {
96232       {
96233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96234       };
96235     } catch (Dali::DaliException e) {
96236       {
96237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96238       };
96239     } catch (...) {
96240       {
96241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96242       };
96243     }
96244   }
96245
96246   jresult = result;
96247   return jresult;
96248 }
96249
96250
96251 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96252   unsigned long jresult ;
96253   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96254   std::size_t result;
96255
96256   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96257   {
96258     try {
96259       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96260     } catch (std::out_of_range& e) {
96261       {
96262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96263       };
96264     } catch (std::exception& e) {
96265       {
96266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96267       };
96268     } catch (Dali::DaliException e) {
96269       {
96270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96271       };
96272     } catch (...) {
96273       {
96274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96275       };
96276     }
96277   }
96278
96279   jresult = (unsigned long)result;
96280   return jresult;
96281 }
96282
96283
96284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96285   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96286   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96287
96288   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96289   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96290   {
96291     try {
96292       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96293     } catch (std::out_of_range& e) {
96294       {
96295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96296       };
96297     } catch (std::exception& e) {
96298       {
96299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96300       };
96301     } catch (Dali::DaliException e) {
96302       {
96303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96304       };
96305     } catch (...) {
96306       {
96307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96308       };
96309     }
96310   }
96311
96312 }
96313
96314
96315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96316   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96317   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96318
96319   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96320   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96321   {
96322     try {
96323       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96324     } catch (std::out_of_range& e) {
96325       {
96326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96327       };
96328     } catch (std::exception& e) {
96329       {
96330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96331       };
96332     } catch (Dali::DaliException e) {
96333       {
96334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96335       };
96336     } catch (...) {
96337       {
96338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96339       };
96340     }
96341   }
96342
96343 }
96344
96345
96346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96347   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96348   Dali::Actor arg2 ;
96349   Dali::Actor arg3 ;
96350   Dali::Actor *argp2 ;
96351   Dali::Actor *argp3 ;
96352
96353   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96354   argp2 = (Dali::Actor *)jarg2;
96355   if (!argp2) {
96356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96357     return ;
96358   }
96359   arg2 = *argp2;
96360   argp3 = (Dali::Actor *)jarg3;
96361   if (!argp3) {
96362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96363     return ;
96364   }
96365   arg3 = *argp3;
96366   {
96367     try {
96368       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96369     } catch (std::out_of_range& e) {
96370       {
96371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96372       };
96373     } catch (std::exception& e) {
96374       {
96375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96376       };
96377     } catch (Dali::DaliException e) {
96378       {
96379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96380       };
96381     } catch (...) {
96382       {
96383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96384       };
96385     }
96386   }
96387
96388 }
96389
96390
96391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96392   void * jresult ;
96393   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96394
96395   {
96396     try {
96397       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96398     } catch (std::out_of_range& e) {
96399       {
96400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96401       };
96402     } catch (std::exception& e) {
96403       {
96404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96405       };
96406     } catch (Dali::DaliException e) {
96407       {
96408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96409       };
96410     } catch (...) {
96411       {
96412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96413       };
96414     }
96415   }
96416
96417   jresult = (void *)result;
96418   return jresult;
96419 }
96420
96421
96422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96423   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96424
96425   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96426   {
96427     try {
96428       delete arg1;
96429     } catch (std::out_of_range& e) {
96430       {
96431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96432       };
96433     } catch (std::exception& e) {
96434       {
96435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96436       };
96437     } catch (Dali::DaliException e) {
96438       {
96439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96440       };
96441     } catch (...) {
96442       {
96443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96444       };
96445     }
96446   }
96447
96448 }
96449
96450
96451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96452   unsigned int jresult ;
96453   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96454   bool result;
96455
96456   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96457   {
96458     try {
96459       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96460     } catch (std::out_of_range& e) {
96461       {
96462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96463       };
96464     } catch (std::exception& e) {
96465       {
96466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96467       };
96468     } catch (Dali::DaliException e) {
96469       {
96470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96471       };
96472     } catch (...) {
96473       {
96474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96475       };
96476     }
96477   }
96478
96479   jresult = result;
96480   return jresult;
96481 }
96482
96483
96484 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96485   unsigned long jresult ;
96486   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96487   std::size_t result;
96488
96489   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96490   {
96491     try {
96492       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96493     } catch (std::out_of_range& e) {
96494       {
96495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96496       };
96497     } catch (std::exception& e) {
96498       {
96499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96500       };
96501     } catch (Dali::DaliException e) {
96502       {
96503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96504       };
96505     } catch (...) {
96506       {
96507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96508       };
96509     }
96510   }
96511
96512   jresult = (unsigned long)result;
96513   return jresult;
96514 }
96515
96516
96517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96518   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96519   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96520
96521   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96522   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96523   {
96524     try {
96525       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96526     } catch (std::out_of_range& e) {
96527       {
96528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96529       };
96530     } catch (std::exception& e) {
96531       {
96532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96533       };
96534     } catch (Dali::DaliException e) {
96535       {
96536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96537       };
96538     } catch (...) {
96539       {
96540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96541       };
96542     }
96543   }
96544
96545 }
96546
96547
96548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96549   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96550   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96551
96552   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96553   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96554   {
96555     try {
96556       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96557     } catch (std::out_of_range& e) {
96558       {
96559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96560       };
96561     } catch (std::exception& e) {
96562       {
96563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96564       };
96565     } catch (Dali::DaliException e) {
96566       {
96567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96568       };
96569     } catch (...) {
96570       {
96571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96572       };
96573     }
96574   }
96575
96576 }
96577
96578
96579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96580   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96581   Dali::Actor arg2 ;
96582   bool arg3 ;
96583   Dali::Actor *argp2 ;
96584
96585   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96586   argp2 = (Dali::Actor *)jarg2;
96587   if (!argp2) {
96588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96589     return ;
96590   }
96591   arg2 = *argp2;
96592   arg3 = jarg3 ? true : false;
96593   {
96594     try {
96595       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96596     } catch (std::out_of_range& e) {
96597       {
96598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96599       };
96600     } catch (std::exception& e) {
96601       {
96602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96603       };
96604     } catch (Dali::DaliException e) {
96605       {
96606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96607       };
96608     } catch (...) {
96609       {
96610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96611       };
96612     }
96613   }
96614
96615 }
96616
96617
96618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96619   void * jresult ;
96620   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96621
96622   {
96623     try {
96624       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96625     } catch (std::out_of_range& e) {
96626       {
96627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96628       };
96629     } catch (std::exception& e) {
96630       {
96631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96632       };
96633     } catch (Dali::DaliException e) {
96634       {
96635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96636       };
96637     } catch (...) {
96638       {
96639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96640       };
96641     }
96642   }
96643
96644   jresult = (void *)result;
96645   return jresult;
96646 }
96647
96648
96649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96650   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96651
96652   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96653   {
96654     try {
96655       delete arg1;
96656     } catch (std::out_of_range& e) {
96657       {
96658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96659       };
96660     } catch (std::exception& e) {
96661       {
96662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96663       };
96664     } catch (Dali::DaliException e) {
96665       {
96666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96667       };
96668     } catch (...) {
96669       {
96670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96671       };
96672     }
96673   }
96674
96675 }
96676
96677
96678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96679   unsigned int jresult ;
96680   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96681   bool result;
96682
96683   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96684   {
96685     try {
96686       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);
96687     } catch (std::out_of_range& e) {
96688       {
96689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96690       };
96691     } catch (std::exception& e) {
96692       {
96693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96694       };
96695     } catch (Dali::DaliException e) {
96696       {
96697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96698       };
96699     } catch (...) {
96700       {
96701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96702       };
96703     }
96704   }
96705
96706   jresult = result;
96707   return jresult;
96708 }
96709
96710
96711 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96712   unsigned long jresult ;
96713   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96714   std::size_t result;
96715
96716   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96717   {
96718     try {
96719       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);
96720     } catch (std::out_of_range& e) {
96721       {
96722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96723       };
96724     } catch (std::exception& e) {
96725       {
96726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96727       };
96728     } catch (Dali::DaliException e) {
96729       {
96730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96731       };
96732     } catch (...) {
96733       {
96734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96735       };
96736     }
96737   }
96738
96739   jresult = (unsigned long)result;
96740   return jresult;
96741 }
96742
96743
96744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96745   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96746   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96747
96748   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96749   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96750   {
96751     try {
96752       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96753     } catch (std::out_of_range& e) {
96754       {
96755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96756       };
96757     } catch (std::exception& e) {
96758       {
96759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96760       };
96761     } catch (Dali::DaliException e) {
96762       {
96763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96764       };
96765     } catch (...) {
96766       {
96767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96768       };
96769     }
96770   }
96771
96772 }
96773
96774
96775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96776   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96777   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96778
96779   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96780   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96781   {
96782     try {
96783       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96784     } catch (std::out_of_range& e) {
96785       {
96786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96787       };
96788     } catch (std::exception& e) {
96789       {
96790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96791       };
96792     } catch (Dali::DaliException e) {
96793       {
96794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96795       };
96796     } catch (...) {
96797       {
96798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96799       };
96800     }
96801   }
96802
96803 }
96804
96805
96806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96807   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96808   Dali::Toolkit::StyleManager arg2 ;
96809   Dali::StyleChange::Type arg3 ;
96810   Dali::Toolkit::StyleManager *argp2 ;
96811
96812   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96813   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96814   if (!argp2) {
96815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96816     return ;
96817   }
96818   arg2 = *argp2;
96819   arg3 = (Dali::StyleChange::Type)jarg3;
96820   {
96821     try {
96822       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96823     } catch (std::out_of_range& e) {
96824       {
96825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96826       };
96827     } catch (std::exception& e) {
96828       {
96829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96830       };
96831     } catch (Dali::DaliException e) {
96832       {
96833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96834       };
96835     } catch (...) {
96836       {
96837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96838       };
96839     }
96840   }
96841
96842 }
96843
96844
96845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96846   void * jresult ;
96847   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96848
96849   {
96850     try {
96851       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96852     } catch (std::out_of_range& e) {
96853       {
96854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96855       };
96856     } catch (std::exception& e) {
96857       {
96858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96859       };
96860     } catch (Dali::DaliException e) {
96861       {
96862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96863       };
96864     } catch (...) {
96865       {
96866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96867       };
96868     }
96869   }
96870
96871   jresult = (void *)result;
96872   return jresult;
96873 }
96874
96875
96876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96877   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96878
96879   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96880   {
96881     try {
96882       delete arg1;
96883     } catch (std::out_of_range& e) {
96884       {
96885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96886       };
96887     } catch (std::exception& e) {
96888       {
96889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96890       };
96891     } catch (Dali::DaliException e) {
96892       {
96893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96894       };
96895     } catch (...) {
96896       {
96897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96898       };
96899     }
96900   }
96901
96902 }
96903
96904
96905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96906   unsigned int jresult ;
96907   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96908   bool result;
96909
96910   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96911   {
96912     try {
96913       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96914     } catch (std::out_of_range& e) {
96915       {
96916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96917       };
96918     } catch (std::exception& e) {
96919       {
96920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96921       };
96922     } catch (Dali::DaliException e) {
96923       {
96924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96925       };
96926     } catch (...) {
96927       {
96928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96929       };
96930     }
96931   }
96932
96933   jresult = result;
96934   return jresult;
96935 }
96936
96937
96938 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96939   unsigned long jresult ;
96940   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96941   std::size_t result;
96942
96943   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96944   {
96945     try {
96946       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96947     } catch (std::out_of_range& e) {
96948       {
96949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96950       };
96951     } catch (std::exception& e) {
96952       {
96953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96954       };
96955     } catch (Dali::DaliException e) {
96956       {
96957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96958       };
96959     } catch (...) {
96960       {
96961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96962       };
96963     }
96964   }
96965
96966   jresult = (unsigned long)result;
96967   return jresult;
96968 }
96969
96970
96971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96972   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96973   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96974
96975   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96976   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96977   {
96978     try {
96979       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96980     } catch (std::out_of_range& e) {
96981       {
96982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96983       };
96984     } catch (std::exception& e) {
96985       {
96986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96987       };
96988     } catch (Dali::DaliException e) {
96989       {
96990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96991       };
96992     } catch (...) {
96993       {
96994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96995       };
96996     }
96997   }
96998
96999 }
97000
97001
97002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
97003   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97004   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
97005
97006   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97007   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
97008   {
97009     try {
97010       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
97011     } catch (std::out_of_range& e) {
97012       {
97013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97014       };
97015     } catch (std::exception& e) {
97016       {
97017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97018       };
97019     } catch (Dali::DaliException e) {
97020       {
97021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97022       };
97023     } catch (...) {
97024       {
97025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97026       };
97027     }
97028   }
97029
97030 }
97031
97032
97033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
97034   unsigned int jresult ;
97035   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97036   Dali::Toolkit::Button arg2 ;
97037   Dali::Toolkit::Button *argp2 ;
97038   bool result;
97039
97040   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97041   argp2 = (Dali::Toolkit::Button *)jarg2;
97042   if (!argp2) {
97043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
97044     return 0;
97045   }
97046   arg2 = *argp2;
97047   {
97048     try {
97049       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
97050     } catch (std::out_of_range& e) {
97051       {
97052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97053       };
97054     } catch (std::exception& e) {
97055       {
97056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97057       };
97058     } catch (Dali::DaliException e) {
97059       {
97060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97061       };
97062     } catch (...) {
97063       {
97064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97065       };
97066     }
97067   }
97068
97069   jresult = result;
97070   return jresult;
97071 }
97072
97073
97074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
97075   void * jresult ;
97076   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
97077
97078   {
97079     try {
97080       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
97081     } catch (std::out_of_range& e) {
97082       {
97083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97084       };
97085     } catch (std::exception& e) {
97086       {
97087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97088       };
97089     } catch (Dali::DaliException e) {
97090       {
97091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97092       };
97093     } catch (...) {
97094       {
97095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97096       };
97097     }
97098   }
97099
97100   jresult = (void *)result;
97101   return jresult;
97102 }
97103
97104
97105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
97106   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97107
97108   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97109   {
97110     try {
97111       delete arg1;
97112     } catch (std::out_of_range& e) {
97113       {
97114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97115       };
97116     } catch (std::exception& e) {
97117       {
97118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97119       };
97120     } catch (Dali::DaliException e) {
97121       {
97122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97123       };
97124     } catch (...) {
97125       {
97126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97127       };
97128     }
97129   }
97130
97131 }
97132
97133
97134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
97135   unsigned int jresult ;
97136   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97137   bool result;
97138
97139   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97140   {
97141     try {
97142       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97143     } catch (std::out_of_range& e) {
97144       {
97145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97146       };
97147     } catch (std::exception& e) {
97148       {
97149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97150       };
97151     } catch (Dali::DaliException e) {
97152       {
97153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97154       };
97155     } catch (...) {
97156       {
97157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97158       };
97159     }
97160   }
97161
97162   jresult = result;
97163   return jresult;
97164 }
97165
97166
97167 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97168   unsigned long jresult ;
97169   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97170   std::size_t result;
97171
97172   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97173   {
97174     try {
97175       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97176     } catch (std::out_of_range& e) {
97177       {
97178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97179       };
97180     } catch (std::exception& e) {
97181       {
97182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97183       };
97184     } catch (Dali::DaliException e) {
97185       {
97186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97187       };
97188     } catch (...) {
97189       {
97190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97191       };
97192     }
97193   }
97194
97195   jresult = (unsigned long)result;
97196   return jresult;
97197 }
97198
97199
97200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97201   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97202   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97203
97204   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97205   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97206   {
97207     try {
97208       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97209     } catch (std::out_of_range& e) {
97210       {
97211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97212       };
97213     } catch (std::exception& e) {
97214       {
97215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97216       };
97217     } catch (Dali::DaliException e) {
97218       {
97219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97220       };
97221     } catch (...) {
97222       {
97223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97224       };
97225     }
97226   }
97227
97228 }
97229
97230
97231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97232   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97233   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97234
97235   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97236   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97237   {
97238     try {
97239       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97240     } catch (std::out_of_range& e) {
97241       {
97242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97243       };
97244     } catch (std::exception& e) {
97245       {
97246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97247       };
97248     } catch (Dali::DaliException e) {
97249       {
97250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97251       };
97252     } catch (...) {
97253       {
97254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97255       };
97256     }
97257   }
97258
97259 }
97260
97261
97262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97263   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97264   Dali::Toolkit::GaussianBlurView arg2 ;
97265   Dali::Toolkit::GaussianBlurView *argp2 ;
97266
97267   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97268   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97269   if (!argp2) {
97270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97271     return ;
97272   }
97273   arg2 = *argp2;
97274   {
97275     try {
97276       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
97277     } catch (std::out_of_range& e) {
97278       {
97279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97280       };
97281     } catch (std::exception& e) {
97282       {
97283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97284       };
97285     } catch (Dali::DaliException e) {
97286       {
97287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97288       };
97289     } catch (...) {
97290       {
97291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97292       };
97293     }
97294   }
97295
97296 }
97297
97298
97299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
97300   void * jresult ;
97301   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97302
97303   {
97304     try {
97305       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97306     } catch (std::out_of_range& e) {
97307       {
97308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97309       };
97310     } catch (std::exception& e) {
97311       {
97312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97313       };
97314     } catch (Dali::DaliException e) {
97315       {
97316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97317       };
97318     } catch (...) {
97319       {
97320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97321       };
97322     }
97323   }
97324
97325   jresult = (void *)result;
97326   return jresult;
97327 }
97328
97329
97330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97331   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97332
97333   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97334   {
97335     try {
97336       delete arg1;
97337     } catch (std::out_of_range& e) {
97338       {
97339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97340       };
97341     } catch (std::exception& e) {
97342       {
97343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97344       };
97345     } catch (Dali::DaliException e) {
97346       {
97347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97348       };
97349     } catch (...) {
97350       {
97351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97352       };
97353     }
97354   }
97355
97356 }
97357
97358
97359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97360   unsigned int jresult ;
97361   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97362   bool result;
97363
97364   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97365   {
97366     try {
97367       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);
97368     } catch (std::out_of_range& e) {
97369       {
97370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97371       };
97372     } catch (std::exception& e) {
97373       {
97374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97375       };
97376     } catch (Dali::DaliException e) {
97377       {
97378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97379       };
97380     } catch (...) {
97381       {
97382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97383       };
97384     }
97385   }
97386
97387   jresult = result;
97388   return jresult;
97389 }
97390
97391
97392 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97393   unsigned long jresult ;
97394   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97395   std::size_t result;
97396
97397   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97398   {
97399     try {
97400       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);
97401     } catch (std::out_of_range& e) {
97402       {
97403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97404       };
97405     } catch (std::exception& e) {
97406       {
97407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97408       };
97409     } catch (Dali::DaliException e) {
97410       {
97411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97412       };
97413     } catch (...) {
97414       {
97415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97416       };
97417     }
97418   }
97419
97420   jresult = (unsigned long)result;
97421   return jresult;
97422 }
97423
97424
97425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97426   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97427   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97428
97429   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97430   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97431   {
97432     try {
97433       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97434     } catch (std::out_of_range& e) {
97435       {
97436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97437       };
97438     } catch (std::exception& e) {
97439       {
97440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97441       };
97442     } catch (Dali::DaliException e) {
97443       {
97444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97445       };
97446     } catch (...) {
97447       {
97448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97449       };
97450     }
97451   }
97452
97453 }
97454
97455
97456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97457   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97458   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97459
97460   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97461   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97462   {
97463     try {
97464       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97465     } catch (std::out_of_range& e) {
97466       {
97467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97468       };
97469     } catch (std::exception& e) {
97470       {
97471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97472       };
97473     } catch (Dali::DaliException e) {
97474       {
97475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97476       };
97477     } catch (...) {
97478       {
97479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97480       };
97481     }
97482   }
97483
97484 }
97485
97486
97487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97488   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97489   Dali::Toolkit::PageTurnView arg2 ;
97490   unsigned int arg3 ;
97491   bool arg4 ;
97492   Dali::Toolkit::PageTurnView *argp2 ;
97493
97494   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97495   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97496   if (!argp2) {
97497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97498     return ;
97499   }
97500   arg2 = *argp2;
97501   arg3 = (unsigned int)jarg3;
97502   arg4 = jarg4 ? true : false;
97503   {
97504     try {
97505       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97506     } catch (std::out_of_range& e) {
97507       {
97508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97509       };
97510     } catch (std::exception& e) {
97511       {
97512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97513       };
97514     } catch (Dali::DaliException e) {
97515       {
97516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97517       };
97518     } catch (...) {
97519       {
97520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97521       };
97522     }
97523   }
97524
97525 }
97526
97527
97528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97529   void * jresult ;
97530   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97531
97532   {
97533     try {
97534       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97535     } catch (std::out_of_range& e) {
97536       {
97537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97538       };
97539     } catch (std::exception& e) {
97540       {
97541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97542       };
97543     } catch (Dali::DaliException e) {
97544       {
97545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97546       };
97547     } catch (...) {
97548       {
97549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97550       };
97551     }
97552   }
97553
97554   jresult = (void *)result;
97555   return jresult;
97556 }
97557
97558
97559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97560   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97561
97562   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97563   {
97564     try {
97565       delete arg1;
97566     } catch (std::out_of_range& e) {
97567       {
97568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97569       };
97570     } catch (std::exception& e) {
97571       {
97572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97573       };
97574     } catch (Dali::DaliException e) {
97575       {
97576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97577       };
97578     } catch (...) {
97579       {
97580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97581       };
97582     }
97583   }
97584
97585 }
97586
97587
97588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97589   unsigned int jresult ;
97590   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97591   bool result;
97592
97593   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97594   {
97595     try {
97596       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97597     } catch (std::out_of_range& e) {
97598       {
97599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97600       };
97601     } catch (std::exception& e) {
97602       {
97603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97604       };
97605     } catch (Dali::DaliException e) {
97606       {
97607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97608       };
97609     } catch (...) {
97610       {
97611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97612       };
97613     }
97614   }
97615
97616   jresult = result;
97617   return jresult;
97618 }
97619
97620
97621 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97622   unsigned long jresult ;
97623   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97624   std::size_t result;
97625
97626   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97627   {
97628     try {
97629       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97630     } catch (std::out_of_range& e) {
97631       {
97632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97633       };
97634     } catch (std::exception& e) {
97635       {
97636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97637       };
97638     } catch (Dali::DaliException e) {
97639       {
97640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97641       };
97642     } catch (...) {
97643       {
97644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97645       };
97646     }
97647   }
97648
97649   jresult = (unsigned long)result;
97650   return jresult;
97651 }
97652
97653
97654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97655   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97656   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97657
97658   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97659   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97660   {
97661     try {
97662       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97663     } catch (std::out_of_range& e) {
97664       {
97665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97666       };
97667     } catch (std::exception& e) {
97668       {
97669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97670       };
97671     } catch (Dali::DaliException e) {
97672       {
97673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97674       };
97675     } catch (...) {
97676       {
97677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97678       };
97679     }
97680   }
97681
97682 }
97683
97684
97685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97686   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97687   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97688
97689   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97690   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97691   {
97692     try {
97693       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97694     } catch (std::out_of_range& e) {
97695       {
97696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97697       };
97698     } catch (std::exception& e) {
97699       {
97700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97701       };
97702     } catch (Dali::DaliException e) {
97703       {
97704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97705       };
97706     } catch (...) {
97707       {
97708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97709       };
97710     }
97711   }
97712
97713 }
97714
97715
97716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97717   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97718   Dali::Toolkit::PageTurnView arg2 ;
97719   Dali::Toolkit::PageTurnView *argp2 ;
97720
97721   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97722   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97723   if (!argp2) {
97724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97725     return ;
97726   }
97727   arg2 = *argp2;
97728   {
97729     try {
97730       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97731     } catch (std::out_of_range& e) {
97732       {
97733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97734       };
97735     } catch (std::exception& e) {
97736       {
97737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97738       };
97739     } catch (Dali::DaliException e) {
97740       {
97741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97742       };
97743     } catch (...) {
97744       {
97745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97746       };
97747     }
97748   }
97749
97750 }
97751
97752
97753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97754   void * jresult ;
97755   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97756
97757   {
97758     try {
97759       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97760     } catch (std::out_of_range& e) {
97761       {
97762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97763       };
97764     } catch (std::exception& e) {
97765       {
97766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97767       };
97768     } catch (Dali::DaliException e) {
97769       {
97770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97771       };
97772     } catch (...) {
97773       {
97774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97775       };
97776     }
97777   }
97778
97779   jresult = (void *)result;
97780   return jresult;
97781 }
97782
97783
97784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97785   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97786
97787   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97788   {
97789     try {
97790       delete arg1;
97791     } catch (std::out_of_range& e) {
97792       {
97793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97794       };
97795     } catch (std::exception& e) {
97796       {
97797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97798       };
97799     } catch (Dali::DaliException e) {
97800       {
97801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97802       };
97803     } catch (...) {
97804       {
97805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97806       };
97807     }
97808   }
97809
97810 }
97811
97812
97813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97814   unsigned int jresult ;
97815   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97816   bool result;
97817
97818   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97819   {
97820     try {
97821       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);
97822     } catch (std::out_of_range& e) {
97823       {
97824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97825       };
97826     } catch (std::exception& e) {
97827       {
97828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97829       };
97830     } catch (Dali::DaliException e) {
97831       {
97832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97833       };
97834     } catch (...) {
97835       {
97836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97837       };
97838     }
97839   }
97840
97841   jresult = result;
97842   return jresult;
97843 }
97844
97845
97846 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97847   unsigned long jresult ;
97848   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97849   std::size_t result;
97850
97851   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97852   {
97853     try {
97854       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);
97855     } catch (std::out_of_range& e) {
97856       {
97857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97858       };
97859     } catch (std::exception& e) {
97860       {
97861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97862       };
97863     } catch (Dali::DaliException e) {
97864       {
97865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97866       };
97867     } catch (...) {
97868       {
97869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97870       };
97871     }
97872   }
97873
97874   jresult = (unsigned long)result;
97875   return jresult;
97876 }
97877
97878
97879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97880   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97881   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97882
97883   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97884   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97885   {
97886     try {
97887       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97888     } catch (std::out_of_range& e) {
97889       {
97890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97891       };
97892     } catch (std::exception& e) {
97893       {
97894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97895       };
97896     } catch (Dali::DaliException e) {
97897       {
97898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97899       };
97900     } catch (...) {
97901       {
97902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97903       };
97904     }
97905   }
97906
97907 }
97908
97909
97910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97911   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97912   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97913
97914   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97915   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97916   {
97917     try {
97918       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97919     } catch (std::out_of_range& e) {
97920       {
97921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97922       };
97923     } catch (std::exception& e) {
97924       {
97925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97926       };
97927     } catch (Dali::DaliException e) {
97928       {
97929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97930       };
97931     } catch (...) {
97932       {
97933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97934       };
97935     }
97936   }
97937
97938 }
97939
97940
97941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97942   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97943   Dali::Toolkit::ProgressBar arg2 ;
97944   float arg3 ;
97945   float arg4 ;
97946   Dali::Toolkit::ProgressBar *argp2 ;
97947
97948   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97949   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97950   if (!argp2) {
97951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97952     return ;
97953   }
97954   arg2 = *argp2;
97955   arg3 = (float)jarg3;
97956   arg4 = (float)jarg4;
97957   {
97958     try {
97959       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97960     } catch (std::out_of_range& e) {
97961       {
97962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97963       };
97964     } catch (std::exception& e) {
97965       {
97966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97967       };
97968     } catch (Dali::DaliException e) {
97969       {
97970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97971       };
97972     } catch (...) {
97973       {
97974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97975       };
97976     }
97977   }
97978
97979 }
97980
97981
97982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97983   void * jresult ;
97984   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97985
97986   {
97987     try {
97988       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97989     } catch (std::out_of_range& e) {
97990       {
97991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97992       };
97993     } catch (std::exception& e) {
97994       {
97995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97996       };
97997     } catch (Dali::DaliException e) {
97998       {
97999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98000       };
98001     } catch (...) {
98002       {
98003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98004       };
98005     }
98006   }
98007
98008   jresult = (void *)result;
98009   return jresult;
98010 }
98011
98012
98013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
98014   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98015
98016   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98017   {
98018     try {
98019       delete arg1;
98020     } catch (std::out_of_range& e) {
98021       {
98022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98023       };
98024     } catch (std::exception& e) {
98025       {
98026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98027       };
98028     } catch (Dali::DaliException e) {
98029       {
98030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98031       };
98032     } catch (...) {
98033       {
98034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98035       };
98036     }
98037   }
98038
98039 }
98040
98041
98042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
98043   unsigned int jresult ;
98044   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98045   bool result;
98046
98047   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98048   {
98049     try {
98050       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);
98051     } catch (std::out_of_range& e) {
98052       {
98053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98054       };
98055     } catch (std::exception& e) {
98056       {
98057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98058       };
98059     } catch (Dali::DaliException e) {
98060       {
98061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98062       };
98063     } catch (...) {
98064       {
98065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98066       };
98067     }
98068   }
98069
98070   jresult = result;
98071   return jresult;
98072 }
98073
98074
98075 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
98076   unsigned long jresult ;
98077   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98078   std::size_t result;
98079
98080   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98081   {
98082     try {
98083       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);
98084     } catch (std::out_of_range& e) {
98085       {
98086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98087       };
98088     } catch (std::exception& e) {
98089       {
98090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98091       };
98092     } catch (Dali::DaliException e) {
98093       {
98094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98095       };
98096     } catch (...) {
98097       {
98098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98099       };
98100     }
98101   }
98102
98103   jresult = (unsigned long)result;
98104   return jresult;
98105 }
98106
98107
98108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
98109   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98110   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98111
98112   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98113   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98114   {
98115     try {
98116       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98117     } catch (std::out_of_range& e) {
98118       {
98119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98120       };
98121     } catch (std::exception& e) {
98122       {
98123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98124       };
98125     } catch (Dali::DaliException e) {
98126       {
98127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98128       };
98129     } catch (...) {
98130       {
98131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98132       };
98133     }
98134   }
98135
98136 }
98137
98138
98139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98140   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98141   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98142
98143   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98144   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98145   {
98146     try {
98147       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98148     } catch (std::out_of_range& e) {
98149       {
98150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98151       };
98152     } catch (std::exception& e) {
98153       {
98154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98155       };
98156     } catch (Dali::DaliException e) {
98157       {
98158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98159       };
98160     } catch (...) {
98161       {
98162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98163       };
98164     }
98165   }
98166
98167 }
98168
98169
98170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98171   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98172   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98173
98174   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98175   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98176   if (!arg2) {
98177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98178     return ;
98179   }
98180   {
98181     try {
98182       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98183     } catch (std::out_of_range& e) {
98184       {
98185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98186       };
98187     } catch (std::exception& e) {
98188       {
98189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98190       };
98191     } catch (Dali::DaliException e) {
98192       {
98193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98194       };
98195     } catch (...) {
98196       {
98197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98198       };
98199     }
98200   }
98201
98202 }
98203
98204
98205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98206   void * jresult ;
98207   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98208
98209   {
98210     try {
98211       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98212     } catch (std::out_of_range& e) {
98213       {
98214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98215       };
98216     } catch (std::exception& e) {
98217       {
98218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98219       };
98220     } catch (Dali::DaliException e) {
98221       {
98222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98223       };
98224     } catch (...) {
98225       {
98226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98227       };
98228     }
98229   }
98230
98231   jresult = (void *)result;
98232   return jresult;
98233 }
98234
98235
98236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98237   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98238
98239   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98240   {
98241     try {
98242       delete arg1;
98243     } catch (std::out_of_range& e) {
98244       {
98245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98246       };
98247     } catch (std::exception& e) {
98248       {
98249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98250       };
98251     } catch (Dali::DaliException e) {
98252       {
98253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98254       };
98255     } catch (...) {
98256       {
98257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98258       };
98259     }
98260   }
98261
98262 }
98263
98264
98265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98266   unsigned int jresult ;
98267   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98268   bool result;
98269
98270   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98271   {
98272     try {
98273       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98274     } catch (std::out_of_range& e) {
98275       {
98276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98277       };
98278     } catch (std::exception& e) {
98279       {
98280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98281       };
98282     } catch (Dali::DaliException e) {
98283       {
98284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98285       };
98286     } catch (...) {
98287       {
98288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98289       };
98290     }
98291   }
98292
98293   jresult = result;
98294   return jresult;
98295 }
98296
98297
98298 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98299   unsigned long jresult ;
98300   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98301   std::size_t result;
98302
98303   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98304   {
98305     try {
98306       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98307     } catch (std::out_of_range& e) {
98308       {
98309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98310       };
98311     } catch (std::exception& e) {
98312       {
98313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98314       };
98315     } catch (Dali::DaliException e) {
98316       {
98317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98318       };
98319     } catch (...) {
98320       {
98321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98322       };
98323     }
98324   }
98325
98326   jresult = (unsigned long)result;
98327   return jresult;
98328 }
98329
98330
98331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98332   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98333   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98334
98335   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98336   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98337   {
98338     try {
98339       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98340     } catch (std::out_of_range& e) {
98341       {
98342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98343       };
98344     } catch (std::exception& e) {
98345       {
98346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98347       };
98348     } catch (Dali::DaliException e) {
98349       {
98350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98351       };
98352     } catch (...) {
98353       {
98354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98355       };
98356     }
98357   }
98358
98359 }
98360
98361
98362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98363   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98364   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98365
98366   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98367   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98368   {
98369     try {
98370       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98371     } catch (std::out_of_range& e) {
98372       {
98373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98374       };
98375     } catch (std::exception& e) {
98376       {
98377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98378       };
98379     } catch (Dali::DaliException e) {
98380       {
98381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98382       };
98383     } catch (...) {
98384       {
98385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98386       };
98387     }
98388   }
98389
98390 }
98391
98392
98393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98394   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98395   Dali::Vector2 *arg2 = 0 ;
98396
98397   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98398   arg2 = (Dali::Vector2 *)jarg2;
98399   if (!arg2) {
98400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98401     return ;
98402   }
98403   {
98404     try {
98405       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98406     } catch (std::out_of_range& e) {
98407       {
98408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98409       };
98410     } catch (std::exception& e) {
98411       {
98412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98413       };
98414     } catch (Dali::DaliException e) {
98415       {
98416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98417       };
98418     } catch (...) {
98419       {
98420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98421       };
98422     }
98423   }
98424
98425 }
98426
98427
98428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98429   void * jresult ;
98430   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98431
98432   {
98433     try {
98434       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98435     } catch (std::out_of_range& e) {
98436       {
98437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98438       };
98439     } catch (std::exception& e) {
98440       {
98441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98442       };
98443     } catch (Dali::DaliException e) {
98444       {
98445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98446       };
98447     } catch (...) {
98448       {
98449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98450       };
98451     }
98452   }
98453
98454   jresult = (void *)result;
98455   return jresult;
98456 }
98457
98458
98459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98460   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98461
98462   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98463   {
98464     try {
98465       delete arg1;
98466     } catch (std::out_of_range& e) {
98467       {
98468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98469       };
98470     } catch (std::exception& e) {
98471       {
98472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98473       };
98474     } catch (Dali::DaliException e) {
98475       {
98476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98477       };
98478     } catch (...) {
98479       {
98480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98481       };
98482     }
98483   }
98484
98485 }
98486
98487
98488
98489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98490   unsigned int jresult ;
98491   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98492   bool result;
98493
98494   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98495   {
98496     try {
98497       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);
98498     } catch (std::out_of_range& e) {
98499       {
98500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98501       };
98502     } catch (std::exception& e) {
98503       {
98504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98505       };
98506     } catch (Dali::DaliException e) {
98507       {
98508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98509       };
98510     } catch (...) {
98511       {
98512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98513       };
98514     }
98515   }
98516
98517   jresult = result;
98518   return jresult;
98519 }
98520
98521
98522 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98523   unsigned long jresult ;
98524   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98525   std::size_t result;
98526
98527   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98528   {
98529     try {
98530       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);
98531     } catch (std::out_of_range& e) {
98532       {
98533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98534       };
98535     } catch (std::exception& e) {
98536       {
98537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98538       };
98539     } catch (Dali::DaliException e) {
98540       {
98541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98542       };
98543     } catch (...) {
98544       {
98545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98546       };
98547     }
98548   }
98549
98550   jresult = (unsigned long)result;
98551   return jresult;
98552 }
98553
98554
98555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98556   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98557   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98558
98559   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98560   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98561   {
98562     try {
98563       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98564     } catch (std::out_of_range& e) {
98565       {
98566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98567       };
98568     } catch (std::exception& e) {
98569       {
98570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98571       };
98572     } catch (Dali::DaliException e) {
98573       {
98574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98575       };
98576     } catch (...) {
98577       {
98578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98579       };
98580     }
98581   }
98582
98583 }
98584
98585
98586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98587   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98588   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98589
98590   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98591   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98592   {
98593     try {
98594       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98595     } catch (std::out_of_range& e) {
98596       {
98597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98598       };
98599     } catch (std::exception& e) {
98600       {
98601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98602       };
98603     } catch (Dali::DaliException e) {
98604       {
98605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98606       };
98607     } catch (...) {
98608       {
98609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98610       };
98611     }
98612   }
98613
98614 }
98615
98616
98617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98618   unsigned int jresult ;
98619   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98620   Dali::Toolkit::Control arg2 ;
98621   Dali::KeyEvent *arg3 = 0 ;
98622   Dali::Toolkit::Control *argp2 ;
98623   bool result;
98624
98625   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98626   argp2 = (Dali::Toolkit::Control *)jarg2;
98627   if (!argp2) {
98628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98629     return 0;
98630   }
98631   arg2 = *argp2;
98632   arg3 = (Dali::KeyEvent *)jarg3;
98633   if (!arg3) {
98634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98635     return 0;
98636   }
98637   {
98638     try {
98639       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);
98640     } catch (std::out_of_range& e) {
98641       {
98642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98643       };
98644     } catch (std::exception& e) {
98645       {
98646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98647       };
98648     } catch (Dali::DaliException e) {
98649       {
98650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98651       };
98652     } catch (...) {
98653       {
98654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98655       };
98656     }
98657   }
98658
98659   jresult = result;
98660   return jresult;
98661 }
98662
98663
98664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98665   void * jresult ;
98666   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98667
98668   {
98669     try {
98670       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98671     } catch (std::out_of_range& e) {
98672       {
98673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98674       };
98675     } catch (std::exception& e) {
98676       {
98677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98678       };
98679     } catch (Dali::DaliException e) {
98680       {
98681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98682       };
98683     } catch (...) {
98684       {
98685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98686       };
98687     }
98688   }
98689
98690   jresult = (void *)result;
98691   return jresult;
98692 }
98693
98694
98695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98696   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98697
98698   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98699   {
98700     try {
98701       delete arg1;
98702     } catch (std::out_of_range& e) {
98703       {
98704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98705       };
98706     } catch (std::exception& e) {
98707       {
98708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98709       };
98710     } catch (Dali::DaliException e) {
98711       {
98712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98713       };
98714     } catch (...) {
98715       {
98716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98717       };
98718     }
98719   }
98720
98721 }
98722
98723
98724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98725   unsigned int jresult ;
98726   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98727   bool result;
98728
98729   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98730   {
98731     try {
98732       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98733     } catch (std::out_of_range& e) {
98734       {
98735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98736       };
98737     } catch (std::exception& e) {
98738       {
98739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98740       };
98741     } catch (Dali::DaliException e) {
98742       {
98743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98744       };
98745     } catch (...) {
98746       {
98747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98748       };
98749     }
98750   }
98751
98752   jresult = result;
98753   return jresult;
98754 }
98755
98756
98757 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98758   unsigned long jresult ;
98759   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98760   std::size_t result;
98761
98762   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98763   {
98764     try {
98765       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98766     } catch (std::out_of_range& e) {
98767       {
98768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98769       };
98770     } catch (std::exception& e) {
98771       {
98772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98773       };
98774     } catch (Dali::DaliException e) {
98775       {
98776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98777       };
98778     } catch (...) {
98779       {
98780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98781       };
98782     }
98783   }
98784
98785   jresult = (unsigned long)result;
98786   return jresult;
98787 }
98788
98789
98790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98791   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98792   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98793
98794   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98795   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98796   {
98797     try {
98798       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98799     } catch (std::out_of_range& e) {
98800       {
98801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98802       };
98803     } catch (std::exception& e) {
98804       {
98805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98806       };
98807     } catch (Dali::DaliException e) {
98808       {
98809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98810       };
98811     } catch (...) {
98812       {
98813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98814       };
98815     }
98816   }
98817
98818 }
98819
98820
98821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98822   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98823   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98824
98825   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98826   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98827   {
98828     try {
98829       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98830     } catch (std::out_of_range& e) {
98831       {
98832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98833       };
98834     } catch (std::exception& e) {
98835       {
98836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98837       };
98838     } catch (Dali::DaliException e) {
98839       {
98840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98841       };
98842     } catch (...) {
98843       {
98844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98845       };
98846     }
98847   }
98848
98849 }
98850
98851
98852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98853   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98854   Dali::Toolkit::Control arg2 ;
98855   Dali::Toolkit::Control *argp2 ;
98856
98857   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98858   argp2 = (Dali::Toolkit::Control *)jarg2;
98859   if (!argp2) {
98860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98861     return ;
98862   }
98863   arg2 = *argp2;
98864   {
98865     try {
98866       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98867     } catch (std::out_of_range& e) {
98868       {
98869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98870       };
98871     } catch (std::exception& e) {
98872       {
98873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98874       };
98875     } catch (Dali::DaliException e) {
98876       {
98877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98878       };
98879     } catch (...) {
98880       {
98881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98882       };
98883     }
98884   }
98885
98886 }
98887
98888
98889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98890   void * jresult ;
98891   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98892
98893   {
98894     try {
98895       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98896     } catch (std::out_of_range& e) {
98897       {
98898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98899       };
98900     } catch (std::exception& e) {
98901       {
98902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98903       };
98904     } catch (Dali::DaliException e) {
98905       {
98906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98907       };
98908     } catch (...) {
98909       {
98910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98911       };
98912     }
98913   }
98914
98915   jresult = (void *)result;
98916   return jresult;
98917 }
98918
98919
98920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98921   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98922
98923   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98924   {
98925     try {
98926       delete arg1;
98927     } catch (std::out_of_range& e) {
98928       {
98929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98930       };
98931     } catch (std::exception& e) {
98932       {
98933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98934       };
98935     } catch (Dali::DaliException e) {
98936       {
98937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98938       };
98939     } catch (...) {
98940       {
98941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98942       };
98943     }
98944   }
98945
98946 }
98947
98948
98949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98950   unsigned int jresult ;
98951   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98952   bool result;
98953
98954   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98955   {
98956     try {
98957       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98958     } catch (std::out_of_range& e) {
98959       {
98960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98961       };
98962     } catch (std::exception& e) {
98963       {
98964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98965       };
98966     } catch (Dali::DaliException e) {
98967       {
98968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98969       };
98970     } catch (...) {
98971       {
98972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98973       };
98974     }
98975   }
98976
98977   jresult = result;
98978   return jresult;
98979 }
98980
98981
98982 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98983   unsigned long jresult ;
98984   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98985   std::size_t result;
98986
98987   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98988   {
98989     try {
98990       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98991     } catch (std::out_of_range& e) {
98992       {
98993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98994       };
98995     } catch (std::exception& e) {
98996       {
98997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98998       };
98999     } catch (Dali::DaliException e) {
99000       {
99001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99002       };
99003     } catch (...) {
99004       {
99005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99006       };
99007     }
99008   }
99009
99010   jresult = (unsigned long)result;
99011   return jresult;
99012 }
99013
99014
99015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
99016   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99017   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99018
99019   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99020   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99021   {
99022     try {
99023       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
99024     } catch (std::out_of_range& e) {
99025       {
99026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99027       };
99028     } catch (std::exception& e) {
99029       {
99030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99031       };
99032     } catch (Dali::DaliException e) {
99033       {
99034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99035       };
99036     } catch (...) {
99037       {
99038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99039       };
99040     }
99041   }
99042
99043 }
99044
99045
99046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
99047   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99048   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99049
99050   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99051   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99052   {
99053     try {
99054       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
99055     } catch (std::out_of_range& e) {
99056       {
99057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99058       };
99059     } catch (std::exception& e) {
99060       {
99061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99062       };
99063     } catch (Dali::DaliException e) {
99064       {
99065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99066       };
99067     } catch (...) {
99068       {
99069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99070       };
99071     }
99072   }
99073
99074 }
99075
99076
99077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
99078   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99079   Dali::Toolkit::VideoView *arg2 = 0 ;
99080
99081   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99082   arg2 = (Dali::Toolkit::VideoView *)jarg2;
99083   if (!arg2) {
99084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
99085     return ;
99086   }
99087   {
99088     try {
99089       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
99090     } catch (std::out_of_range& e) {
99091       {
99092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99093       };
99094     } catch (std::exception& e) {
99095       {
99096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99097       };
99098     } catch (Dali::DaliException e) {
99099       {
99100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99101       };
99102     } catch (...) {
99103       {
99104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99105       };
99106     }
99107   }
99108
99109 }
99110
99111
99112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
99113   void * jresult ;
99114   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
99115
99116   {
99117     try {
99118       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
99119     } catch (std::out_of_range& e) {
99120       {
99121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99122       };
99123     } catch (std::exception& e) {
99124       {
99125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99126       };
99127     } catch (Dali::DaliException e) {
99128       {
99129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99130       };
99131     } catch (...) {
99132       {
99133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99134       };
99135     }
99136   }
99137
99138   jresult = (void *)result;
99139   return jresult;
99140 }
99141
99142
99143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99144   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99145
99146   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99147   {
99148     try {
99149       delete arg1;
99150     } catch (std::out_of_range& e) {
99151       {
99152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99153       };
99154     } catch (std::exception& e) {
99155       {
99156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99157       };
99158     } catch (Dali::DaliException e) {
99159       {
99160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99161       };
99162     } catch (...) {
99163       {
99164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99165       };
99166     }
99167   }
99168
99169 }
99170
99171
99172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99173   unsigned int jresult ;
99174   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99175   bool result;
99176
99177   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99178   {
99179     try {
99180       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99181     } catch (std::out_of_range& e) {
99182       {
99183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99184       };
99185     } catch (std::exception& e) {
99186       {
99187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99188       };
99189     } catch (Dali::DaliException e) {
99190       {
99191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99192       };
99193     } catch (...) {
99194       {
99195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99196       };
99197     }
99198   }
99199
99200   jresult = result;
99201   return jresult;
99202 }
99203
99204
99205 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99206   unsigned long jresult ;
99207   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99208   std::size_t result;
99209
99210   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99211   {
99212     try {
99213       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99214     } catch (std::out_of_range& e) {
99215       {
99216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99217       };
99218     } catch (std::exception& e) {
99219       {
99220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99221       };
99222     } catch (Dali::DaliException e) {
99223       {
99224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99225       };
99226     } catch (...) {
99227       {
99228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99229       };
99230     }
99231   }
99232
99233   jresult = (unsigned long)result;
99234   return jresult;
99235 }
99236
99237
99238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99239   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99240   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99241
99242   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99243   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99244   {
99245     try {
99246       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99247     } catch (std::out_of_range& e) {
99248       {
99249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99250       };
99251     } catch (std::exception& e) {
99252       {
99253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99254       };
99255     } catch (Dali::DaliException e) {
99256       {
99257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99258       };
99259     } catch (...) {
99260       {
99261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99262       };
99263     }
99264   }
99265
99266 }
99267
99268
99269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99270   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99271   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99272
99273   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99274   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99275   {
99276     try {
99277       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99278     } catch (std::out_of_range& e) {
99279       {
99280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99281       };
99282     } catch (std::exception& e) {
99283       {
99284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99285       };
99286     } catch (Dali::DaliException e) {
99287       {
99288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99289       };
99290     } catch (...) {
99291       {
99292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99293       };
99294     }
99295   }
99296
99297 }
99298
99299
99300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99301   unsigned int jresult ;
99302   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99303   Dali::Toolkit::Slider arg2 ;
99304   float arg3 ;
99305   Dali::Toolkit::Slider *argp2 ;
99306   bool result;
99307
99308   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99309   argp2 = (Dali::Toolkit::Slider *)jarg2;
99310   if (!argp2) {
99311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99312     return 0;
99313   }
99314   arg2 = *argp2;
99315   arg3 = (float)jarg3;
99316   {
99317     try {
99318       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99319     } catch (std::out_of_range& e) {
99320       {
99321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99322       };
99323     } catch (std::exception& e) {
99324       {
99325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99326       };
99327     } catch (Dali::DaliException e) {
99328       {
99329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99330       };
99331     } catch (...) {
99332       {
99333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99334       };
99335     }
99336   }
99337
99338   jresult = result;
99339   return jresult;
99340 }
99341
99342
99343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99344   void * jresult ;
99345   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99346
99347   {
99348     try {
99349       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99350     } catch (std::out_of_range& e) {
99351       {
99352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99353       };
99354     } catch (std::exception& e) {
99355       {
99356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99357       };
99358     } catch (Dali::DaliException e) {
99359       {
99360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99361       };
99362     } catch (...) {
99363       {
99364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99365       };
99366     }
99367   }
99368
99369   jresult = (void *)result;
99370   return jresult;
99371 }
99372
99373
99374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99375   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99376
99377   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99378   {
99379     try {
99380       delete arg1;
99381     } catch (std::out_of_range& e) {
99382       {
99383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99384       };
99385     } catch (std::exception& e) {
99386       {
99387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99388       };
99389     } catch (Dali::DaliException e) {
99390       {
99391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99392       };
99393     } catch (...) {
99394       {
99395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99396       };
99397     }
99398   }
99399
99400 }
99401
99402
99403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99404   unsigned int jresult ;
99405   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99406   bool result;
99407
99408   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99409   {
99410     try {
99411       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99412     } catch (std::out_of_range& e) {
99413       {
99414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99415       };
99416     } catch (std::exception& e) {
99417       {
99418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99419       };
99420     } catch (Dali::DaliException e) {
99421       {
99422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99423       };
99424     } catch (...) {
99425       {
99426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99427       };
99428     }
99429   }
99430
99431   jresult = result;
99432   return jresult;
99433 }
99434
99435
99436 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99437   unsigned long jresult ;
99438   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99439   std::size_t result;
99440
99441   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99442   {
99443     try {
99444       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99445     } catch (std::out_of_range& e) {
99446       {
99447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99448       };
99449     } catch (std::exception& e) {
99450       {
99451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99452       };
99453     } catch (Dali::DaliException e) {
99454       {
99455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99456       };
99457     } catch (...) {
99458       {
99459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99460       };
99461     }
99462   }
99463
99464   jresult = (unsigned long)result;
99465   return jresult;
99466 }
99467
99468
99469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99470   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99471   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99472
99473   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99474   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99475   {
99476     try {
99477       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99478     } catch (std::out_of_range& e) {
99479       {
99480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99481       };
99482     } catch (std::exception& e) {
99483       {
99484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99485       };
99486     } catch (Dali::DaliException e) {
99487       {
99488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99489       };
99490     } catch (...) {
99491       {
99492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99493       };
99494     }
99495   }
99496
99497 }
99498
99499
99500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99501   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99502   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99503
99504   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99505   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99506   {
99507     try {
99508       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99509     } catch (std::out_of_range& e) {
99510       {
99511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99512       };
99513     } catch (std::exception& e) {
99514       {
99515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99516       };
99517     } catch (Dali::DaliException e) {
99518       {
99519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99520       };
99521     } catch (...) {
99522       {
99523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99524       };
99525     }
99526   }
99527
99528 }
99529
99530
99531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99532   unsigned int jresult ;
99533   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99534   Dali::Toolkit::Slider arg2 ;
99535   int arg3 ;
99536   Dali::Toolkit::Slider *argp2 ;
99537   bool result;
99538
99539   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99540   argp2 = (Dali::Toolkit::Slider *)jarg2;
99541   if (!argp2) {
99542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99543     return 0;
99544   }
99545   arg2 = *argp2;
99546   arg3 = (int)jarg3;
99547   {
99548     try {
99549       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99550     } catch (std::out_of_range& e) {
99551       {
99552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99553       };
99554     } catch (std::exception& e) {
99555       {
99556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99557       };
99558     } catch (Dali::DaliException e) {
99559       {
99560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99561       };
99562     } catch (...) {
99563       {
99564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99565       };
99566     }
99567   }
99568
99569   jresult = result;
99570   return jresult;
99571 }
99572
99573
99574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99575   void * jresult ;
99576   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99577
99578   {
99579     try {
99580       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99581     } catch (std::out_of_range& e) {
99582       {
99583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99584       };
99585     } catch (std::exception& e) {
99586       {
99587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99588       };
99589     } catch (Dali::DaliException e) {
99590       {
99591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99592       };
99593     } catch (...) {
99594       {
99595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99596       };
99597     }
99598   }
99599
99600   jresult = (void *)result;
99601   return jresult;
99602 }
99603
99604
99605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99606   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99607
99608   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99609   {
99610     try {
99611       delete arg1;
99612     } catch (std::out_of_range& e) {
99613       {
99614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99615       };
99616     } catch (std::exception& e) {
99617       {
99618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99619       };
99620     } catch (Dali::DaliException e) {
99621       {
99622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99623       };
99624     } catch (...) {
99625       {
99626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99627       };
99628     }
99629   }
99630
99631 }
99632
99633
99634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99635   void * jresult ;
99636   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99637
99638   {
99639     try {
99640       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99641     } catch (std::out_of_range& e) {
99642       {
99643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99644       };
99645     } catch (std::exception& e) {
99646       {
99647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99648       };
99649     } catch (Dali::DaliException e) {
99650       {
99651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99652       };
99653     } catch (...) {
99654       {
99655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99656       };
99657     }
99658   }
99659
99660   jresult = (void *)result;
99661   return jresult;
99662 }
99663
99664
99665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99666   void * jresult ;
99667   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99668   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99669
99670   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99671   {
99672     try {
99673       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99674     } catch (std::out_of_range& e) {
99675       {
99676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99677       };
99678     } catch (std::exception& e) {
99679       {
99680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99681       };
99682     } catch (Dali::DaliException e) {
99683       {
99684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99685       };
99686     } catch (...) {
99687       {
99688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99689       };
99690     }
99691   }
99692
99693   jresult = (void *)result;
99694   return jresult;
99695 }
99696
99697
99698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99699   void * jresult ;
99700   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99701   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99702
99703   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99704   if (!arg1) {
99705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99706     return 0;
99707   }
99708   {
99709     try {
99710       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99711     } catch (std::out_of_range& e) {
99712       {
99713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99714       };
99715     } catch (std::exception& e) {
99716       {
99717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99718       };
99719     } catch (Dali::DaliException e) {
99720       {
99721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99722       };
99723     } catch (...) {
99724       {
99725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99726       };
99727     }
99728   }
99729
99730   jresult = (void *)result;
99731   return jresult;
99732 }
99733
99734
99735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99736   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99737
99738   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99739   {
99740     try {
99741       delete arg1;
99742     } catch (std::out_of_range& e) {
99743       {
99744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99745       };
99746     } catch (std::exception& e) {
99747       {
99748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99749       };
99750     } catch (Dali::DaliException e) {
99751       {
99752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99753       };
99754     } catch (...) {
99755       {
99756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99757       };
99758     }
99759   }
99760
99761 }
99762
99763
99764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99765   void * jresult ;
99766   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99767   Dali::Toolkit::Ruler *result = 0 ;
99768
99769   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99770   {
99771     try {
99772       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99773     } catch (std::out_of_range& e) {
99774       {
99775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99776       };
99777     } catch (std::exception& e) {
99778       {
99779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99780       };
99781     } catch (Dali::DaliException e) {
99782       {
99783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99784       };
99785     } catch (...) {
99786       {
99787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99788       };
99789     }
99790   }
99791
99792   jresult = (void *)result;
99793   return jresult;
99794 }
99795
99796
99797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99798   void * jresult ;
99799   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99800   Dali::Toolkit::Ruler *result = 0 ;
99801
99802   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99803   {
99804     try {
99805       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99806     } catch (std::out_of_range& e) {
99807       {
99808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99809       };
99810     } catch (std::exception& e) {
99811       {
99812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99813       };
99814     } catch (Dali::DaliException e) {
99815       {
99816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99817       };
99818     } catch (...) {
99819       {
99820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99821       };
99822     }
99823   }
99824
99825   jresult = (void *)result;
99826   return jresult;
99827 }
99828
99829
99830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99831   void * jresult ;
99832   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99833   Dali::Toolkit::Ruler *result = 0 ;
99834
99835   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99836   {
99837     try {
99838       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
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 = (void *)result;
99859   return jresult;
99860 }
99861
99862
99863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99864   void * jresult ;
99865   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99866   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99867   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99868
99869   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99870   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99871   if (!arg2) {
99872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99873     return 0;
99874   }
99875   {
99876     try {
99877       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
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 = (void *)result;
99898   return jresult;
99899 }
99900
99901
99902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99903   void * jresult ;
99904   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99905   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99906   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99907
99908   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99909   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99910   {
99911     try {
99912       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99913     } catch (std::out_of_range& e) {
99914       {
99915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99916       };
99917     } catch (std::exception& e) {
99918       {
99919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99920       };
99921     } catch (Dali::DaliException e) {
99922       {
99923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99924       };
99925     } catch (...) {
99926       {
99927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99928       };
99929     }
99930   }
99931
99932   jresult = (void *)result;
99933   return jresult;
99934 }
99935
99936
99937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99938   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99939
99940   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99941   {
99942     try {
99943       (arg1)->Reset();
99944     } catch (std::out_of_range& e) {
99945       {
99946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99947       };
99948     } catch (std::exception& e) {
99949       {
99950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99951       };
99952     } catch (Dali::DaliException e) {
99953       {
99954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99955       };
99956     } catch (...) {
99957       {
99958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99959       };
99960     }
99961   }
99962
99963 }
99964
99965
99966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99967   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99968   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99969
99970   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99971   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99972   {
99973     try {
99974       (arg1)->Reset(arg2);
99975     } catch (std::out_of_range& e) {
99976       {
99977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99978       };
99979     } catch (std::exception& e) {
99980       {
99981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99982       };
99983     } catch (Dali::DaliException e) {
99984       {
99985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99986       };
99987     } catch (...) {
99988       {
99989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99990       };
99991     }
99992   }
99993
99994 }
99995
99996
99997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99998   void * jresult ;
99999   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100000   Dali::Toolkit::Ruler *result = 0 ;
100001
100002   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100003   {
100004     try {
100005       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
100006     } catch (std::out_of_range& e) {
100007       {
100008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100009       };
100010     } catch (std::exception& e) {
100011       {
100012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100013       };
100014     } catch (Dali::DaliException e) {
100015       {
100016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100017       };
100018     } catch (...) {
100019       {
100020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100021       };
100022     }
100023   }
100024
100025   jresult = (void *)result;
100026   return jresult;
100027 }
100028
100029
100030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
100031   float jresult ;
100032   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100033   float arg2 ;
100034   float arg3 ;
100035   float result;
100036
100037   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100038   arg2 = (float)jarg2;
100039   arg3 = (float)jarg3;
100040   {
100041     try {
100042       result = (float)(*arg1)->Snap(arg2,arg3);
100043     } catch (std::out_of_range& e) {
100044       {
100045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100046       };
100047     } catch (std::exception& e) {
100048       {
100049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100050       };
100051     } catch (Dali::DaliException e) {
100052       {
100053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100054       };
100055     } catch (...) {
100056       {
100057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100058       };
100059     }
100060   }
100061
100062   jresult = result;
100063   return jresult;
100064 }
100065
100066
100067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
100068   float jresult ;
100069   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100070   float arg2 ;
100071   float result;
100072
100073   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100074   arg2 = (float)jarg2;
100075   {
100076     try {
100077       result = (float)(*arg1)->Snap(arg2);
100078     } catch (std::out_of_range& e) {
100079       {
100080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100081       };
100082     } catch (std::exception& e) {
100083       {
100084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100085       };
100086     } catch (Dali::DaliException e) {
100087       {
100088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100089       };
100090     } catch (...) {
100091       {
100092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100093       };
100094     }
100095   }
100096
100097   jresult = result;
100098   return jresult;
100099 }
100100
100101
100102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
100103   float jresult ;
100104   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100105   unsigned int arg2 ;
100106   unsigned int *arg3 = 0 ;
100107   bool arg4 ;
100108   float result;
100109
100110   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100111   arg2 = (unsigned int)jarg2;
100112   arg3 = (unsigned int *)jarg3;
100113   arg4 = jarg4 ? true : false;
100114   {
100115     try {
100116       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
100117     } catch (std::out_of_range& e) {
100118       {
100119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100120       };
100121     } catch (std::exception& e) {
100122       {
100123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100124       };
100125     } catch (Dali::DaliException e) {
100126       {
100127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100128       };
100129     } catch (...) {
100130       {
100131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100132       };
100133     }
100134   }
100135
100136   jresult = result;
100137   return jresult;
100138 }
100139
100140
100141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100142   unsigned int jresult ;
100143   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100144   float arg2 ;
100145   bool arg3 ;
100146   unsigned int result;
100147
100148   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100149   arg2 = (float)jarg2;
100150   arg3 = jarg3 ? true : false;
100151   {
100152     try {
100153       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
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 = result;
100174   return jresult;
100175 }
100176
100177
100178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
100179   unsigned int jresult ;
100180   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100181   unsigned int result;
100182
100183   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100184   {
100185     try {
100186       result = (unsigned int)(*arg1)->GetTotalPages();
100187     } catch (std::out_of_range& e) {
100188       {
100189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100190       };
100191     } catch (std::exception& e) {
100192       {
100193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100194       };
100195     } catch (Dali::DaliException e) {
100196       {
100197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100198       };
100199     } catch (...) {
100200       {
100201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100202       };
100203     }
100204   }
100205
100206   jresult = result;
100207   return jresult;
100208 }
100209
100210
100211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100212   int jresult ;
100213   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100214   Dali::Toolkit::Ruler::RulerType result;
100215
100216   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100217   {
100218     try {
100219       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100220     } catch (std::out_of_range& e) {
100221       {
100222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100223       };
100224     } catch (std::exception& e) {
100225       {
100226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100227       };
100228     } catch (Dali::DaliException e) {
100229       {
100230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100231       };
100232     } catch (...) {
100233       {
100234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100235       };
100236     }
100237   }
100238
100239   jresult = (int)result;
100240   return jresult;
100241 }
100242
100243
100244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100245   unsigned int jresult ;
100246   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100247   bool result;
100248
100249   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100250   {
100251     try {
100252       result = (bool)(*arg1)->IsEnabled();
100253     } catch (std::out_of_range& e) {
100254       {
100255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100256       };
100257     } catch (std::exception& e) {
100258       {
100259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100260       };
100261     } catch (Dali::DaliException e) {
100262       {
100263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100264       };
100265     } catch (...) {
100266       {
100267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100268       };
100269     }
100270   }
100271
100272   jresult = result;
100273   return jresult;
100274 }
100275
100276
100277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100278   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100279
100280   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100281   {
100282     try {
100283       (*arg1)->Enable();
100284     } catch (std::out_of_range& e) {
100285       {
100286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100287       };
100288     } catch (std::exception& e) {
100289       {
100290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100291       };
100292     } catch (Dali::DaliException e) {
100293       {
100294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100295       };
100296     } catch (...) {
100297       {
100298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100299       };
100300     }
100301   }
100302
100303 }
100304
100305
100306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100307   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100308
100309   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100310   {
100311     try {
100312       (*arg1)->Disable();
100313     } catch (std::out_of_range& e) {
100314       {
100315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100316       };
100317     } catch (std::exception& e) {
100318       {
100319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100320       };
100321     } catch (Dali::DaliException e) {
100322       {
100323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100324       };
100325     } catch (...) {
100326       {
100327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100328       };
100329     }
100330   }
100331
100332 }
100333
100334
100335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100336   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100337   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100338   Dali::Toolkit::RulerDomain *argp2 ;
100339
100340   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100341   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100342   if (!argp2) {
100343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100344     return ;
100345   }
100346   arg2 = *argp2;
100347   {
100348     try {
100349       (*arg1)->SetDomain(arg2);
100350     } catch (std::out_of_range& e) {
100351       {
100352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100353       };
100354     } catch (std::exception& e) {
100355       {
100356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100357       };
100358     } catch (Dali::DaliException e) {
100359       {
100360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100361       };
100362     } catch (...) {
100363       {
100364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100365       };
100366     }
100367   }
100368
100369 }
100370
100371
100372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100373   void * jresult ;
100374   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100375   Dali::Toolkit::RulerDomain *result = 0 ;
100376
100377   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100378   {
100379     try {
100380       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100381     } catch (std::out_of_range& e) {
100382       {
100383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100384       };
100385     } catch (std::exception& e) {
100386       {
100387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100388       };
100389     } catch (Dali::DaliException e) {
100390       {
100391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100392       };
100393     } catch (...) {
100394       {
100395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100396       };
100397     }
100398   }
100399
100400   jresult = (void *)result;
100401   return jresult;
100402 }
100403
100404
100405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100406   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100407
100408   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100409   {
100410     try {
100411       (*arg1)->DisableDomain();
100412     } catch (std::out_of_range& e) {
100413       {
100414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100415       };
100416     } catch (std::exception& e) {
100417       {
100418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100419       };
100420     } catch (Dali::DaliException e) {
100421       {
100422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100423       };
100424     } catch (...) {
100425       {
100426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100427       };
100428     }
100429   }
100430
100431 }
100432
100433
100434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100435   float jresult ;
100436   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100437   float arg2 ;
100438   float arg3 ;
100439   float arg4 ;
100440   float result;
100441
100442   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100443   arg2 = (float)jarg2;
100444   arg3 = (float)jarg3;
100445   arg4 = (float)jarg4;
100446   {
100447     try {
100448       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100449     } catch (std::out_of_range& e) {
100450       {
100451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100452       };
100453     } catch (std::exception& e) {
100454       {
100455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100456       };
100457     } catch (Dali::DaliException e) {
100458       {
100459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100460       };
100461     } catch (...) {
100462       {
100463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100464       };
100465     }
100466   }
100467
100468   jresult = result;
100469   return jresult;
100470 }
100471
100472
100473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100474   float jresult ;
100475   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100476   float arg2 ;
100477   float arg3 ;
100478   float result;
100479
100480   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100481   arg2 = (float)jarg2;
100482   arg3 = (float)jarg3;
100483   {
100484     try {
100485       result = (float)(*arg1)->Clamp(arg2,arg3);
100486     } catch (std::out_of_range& e) {
100487       {
100488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100489       };
100490     } catch (std::exception& e) {
100491       {
100492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100493       };
100494     } catch (Dali::DaliException e) {
100495       {
100496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100497       };
100498     } catch (...) {
100499       {
100500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100501       };
100502     }
100503   }
100504
100505   jresult = result;
100506   return jresult;
100507 }
100508
100509
100510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100511   float jresult ;
100512   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100513   float arg2 ;
100514   float result;
100515
100516   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100517   arg2 = (float)jarg2;
100518   {
100519     try {
100520       result = (float)(*arg1)->Clamp(arg2);
100521     } catch (std::out_of_range& e) {
100522       {
100523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100524       };
100525     } catch (std::exception& e) {
100526       {
100527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100528       };
100529     } catch (Dali::DaliException e) {
100530       {
100531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100532       };
100533     } catch (...) {
100534       {
100535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100536       };
100537     }
100538   }
100539
100540   jresult = result;
100541   return jresult;
100542 }
100543
100544
100545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100546   float jresult ;
100547   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100548   float arg2 ;
100549   float arg3 ;
100550   float arg4 ;
100551   Dali::Toolkit::ClampState *arg5 = 0 ;
100552   float result;
100553
100554   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100555   arg2 = (float)jarg2;
100556   arg3 = (float)jarg3;
100557   arg4 = (float)jarg4;
100558   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100559   if (!arg5) {
100560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100561     return 0;
100562   }
100563   {
100564     try {
100565       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100566     } catch (std::out_of_range& e) {
100567       {
100568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100569       };
100570     } catch (std::exception& e) {
100571       {
100572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100573       };
100574     } catch (Dali::DaliException e) {
100575       {
100576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100577       };
100578     } catch (...) {
100579       {
100580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100581       };
100582     }
100583   }
100584
100585   jresult = result;
100586   return jresult;
100587 }
100588
100589
100590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100591   float jresult ;
100592   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100593   float arg2 ;
100594   float arg3 ;
100595   float arg4 ;
100596   float arg5 ;
100597   float result;
100598
100599   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100600   arg2 = (float)jarg2;
100601   arg3 = (float)jarg3;
100602   arg4 = (float)jarg4;
100603   arg5 = (float)jarg5;
100604   {
100605     try {
100606       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100607     } catch (std::out_of_range& e) {
100608       {
100609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100610       };
100611     } catch (std::exception& e) {
100612       {
100613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100614       };
100615     } catch (Dali::DaliException e) {
100616       {
100617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100618       };
100619     } catch (...) {
100620       {
100621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100622       };
100623     }
100624   }
100625
100626   jresult = result;
100627   return jresult;
100628 }
100629
100630
100631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100632   float jresult ;
100633   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100634   float arg2 ;
100635   float arg3 ;
100636   float arg4 ;
100637   float result;
100638
100639   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100640   arg2 = (float)jarg2;
100641   arg3 = (float)jarg3;
100642   arg4 = (float)jarg4;
100643   {
100644     try {
100645       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100646     } catch (std::out_of_range& e) {
100647       {
100648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100649       };
100650     } catch (std::exception& e) {
100651       {
100652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100653       };
100654     } catch (Dali::DaliException e) {
100655       {
100656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100657       };
100658     } catch (...) {
100659       {
100660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100661       };
100662     }
100663   }
100664
100665   jresult = result;
100666   return jresult;
100667 }
100668
100669
100670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100671   float jresult ;
100672   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100673   float arg2 ;
100674   float arg3 ;
100675   float result;
100676
100677   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100678   arg2 = (float)jarg2;
100679   arg3 = (float)jarg3;
100680   {
100681     try {
100682       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100683     } catch (std::out_of_range& e) {
100684       {
100685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100686       };
100687     } catch (std::exception& e) {
100688       {
100689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100690       };
100691     } catch (Dali::DaliException e) {
100692       {
100693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100694       };
100695     } catch (...) {
100696       {
100697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100698       };
100699     }
100700   }
100701
100702   jresult = result;
100703   return jresult;
100704 }
100705
100706
100707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100708   float jresult ;
100709   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100710   float arg2 ;
100711   float result;
100712
100713   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100714   arg2 = (float)jarg2;
100715   {
100716     try {
100717       result = (float)(*arg1)->SnapAndClamp(arg2);
100718     } catch (std::out_of_range& e) {
100719       {
100720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100721       };
100722     } catch (std::exception& e) {
100723       {
100724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100725       };
100726     } catch (Dali::DaliException e) {
100727       {
100728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100729       };
100730     } catch (...) {
100731       {
100732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100733       };
100734     }
100735   }
100736
100737   jresult = result;
100738   return jresult;
100739 }
100740
100741
100742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100743   float jresult ;
100744   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100745   float arg2 ;
100746   float arg3 ;
100747   float arg4 ;
100748   float arg5 ;
100749   Dali::Toolkit::ClampState *arg6 = 0 ;
100750   float result;
100751
100752   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100753   arg2 = (float)jarg2;
100754   arg3 = (float)jarg3;
100755   arg4 = (float)jarg4;
100756   arg5 = (float)jarg5;
100757   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100758   if (!arg6) {
100759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100760     return 0;
100761   }
100762   {
100763     try {
100764       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100765     } catch (std::out_of_range& e) {
100766       {
100767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100768       };
100769     } catch (std::exception& e) {
100770       {
100771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100772       };
100773     } catch (Dali::DaliException e) {
100774       {
100775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100776       };
100777     } catch (...) {
100778       {
100779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100780       };
100781     }
100782   }
100783
100784   jresult = result;
100785   return jresult;
100786 }
100787
100788
100789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100790   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100791
100792   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100793   {
100794     try {
100795       (*arg1)->Reference();
100796     } catch (std::out_of_range& e) {
100797       {
100798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100799       };
100800     } catch (std::exception& e) {
100801       {
100802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100803       };
100804     } catch (Dali::DaliException e) {
100805       {
100806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100807       };
100808     } catch (...) {
100809       {
100810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100811       };
100812     }
100813   }
100814
100815 }
100816
100817
100818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100819   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100820
100821   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100822   {
100823     try {
100824       (*arg1)->Unreference();
100825     } catch (std::out_of_range& e) {
100826       {
100827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100828       };
100829     } catch (std::exception& e) {
100830       {
100831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100832       };
100833     } catch (Dali::DaliException e) {
100834       {
100835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100836       };
100837     } catch (...) {
100838       {
100839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100840       };
100841     }
100842   }
100843
100844 }
100845
100846
100847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100848   int jresult ;
100849   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100850   int result;
100851
100852   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100853   {
100854     try {
100855       result = (int)(*arg1)->ReferenceCount();
100856     } catch (std::out_of_range& e) {
100857       {
100858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100859       };
100860     } catch (std::exception& e) {
100861       {
100862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100863       };
100864     } catch (Dali::DaliException e) {
100865       {
100866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100867       };
100868     } catch (...) {
100869       {
100870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100871       };
100872     }
100873   }
100874
100875   jresult = result;
100876   return jresult;
100877 }
100878
100879
100880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100881   unsigned int jresult ;
100882   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100883   bool result;
100884
100885   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100886   {
100887     try {
100888       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100889     } catch (std::out_of_range& e) {
100890       {
100891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100892       };
100893     } catch (std::exception& e) {
100894       {
100895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100896       };
100897     } catch (Dali::DaliException e) {
100898       {
100899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100900       };
100901     } catch (...) {
100902       {
100903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100904       };
100905     }
100906   }
100907
100908   jresult = result;
100909   return jresult;
100910 }
100911
100912
100913 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100914   unsigned long jresult ;
100915   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100916   std::size_t result;
100917
100918   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100919   {
100920     try {
100921       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100922     } catch (std::out_of_range& e) {
100923       {
100924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100925       };
100926     } catch (std::exception& e) {
100927       {
100928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100929       };
100930     } catch (Dali::DaliException e) {
100931       {
100932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100933       };
100934     } catch (...) {
100935       {
100936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100937       };
100938     }
100939   }
100940
100941   jresult = (unsigned long)result;
100942   return jresult;
100943 }
100944
100945
100946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100947   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100948   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100949
100950   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100951   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100952   {
100953     try {
100954       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100955     } catch (std::out_of_range& e) {
100956       {
100957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100958       };
100959     } catch (std::exception& e) {
100960       {
100961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100962       };
100963     } catch (Dali::DaliException e) {
100964       {
100965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100966       };
100967     } catch (...) {
100968       {
100969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100970       };
100971     }
100972   }
100973
100974 }
100975
100976
100977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100978   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100979   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100980
100981   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100982   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100983   {
100984     try {
100985       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100986     } catch (std::out_of_range& e) {
100987       {
100988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100989       };
100990     } catch (std::exception& e) {
100991       {
100992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100993       };
100994     } catch (Dali::DaliException e) {
100995       {
100996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100997       };
100998     } catch (...) {
100999       {
101000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101001       };
101002     }
101003   }
101004
101005 }
101006
101007
101008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
101009   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101010   Dali::Toolkit::Control arg2 ;
101011   Dali::Toolkit::Control *argp2 ;
101012
101013   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101014   argp2 = (Dali::Toolkit::Control *)jarg2;
101015   if (!argp2) {
101016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
101017     return ;
101018   }
101019   arg2 = *argp2;
101020   {
101021     try {
101022       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
101023     } catch (std::out_of_range& e) {
101024       {
101025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101026       };
101027     } catch (std::exception& e) {
101028       {
101029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101030       };
101031     } catch (Dali::DaliException e) {
101032       {
101033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101034       };
101035     } catch (...) {
101036       {
101037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101038       };
101039     }
101040   }
101041
101042 }
101043
101044
101045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
101046   void * jresult ;
101047   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
101048
101049   {
101050     try {
101051       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
101052     } catch (std::out_of_range& e) {
101053       {
101054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101055       };
101056     } catch (std::exception& e) {
101057       {
101058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101059       };
101060     } catch (Dali::DaliException e) {
101061       {
101062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101063       };
101064     } catch (...) {
101065       {
101066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101067       };
101068     }
101069   }
101070
101071   jresult = (void *)result;
101072   return jresult;
101073 }
101074
101075
101076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
101077   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101078
101079   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101080   {
101081     try {
101082       delete arg1;
101083     } catch (std::out_of_range& e) {
101084       {
101085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101086       };
101087     } catch (std::exception& e) {
101088       {
101089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101090       };
101091     } catch (Dali::DaliException e) {
101092       {
101093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101094       };
101095     } catch (...) {
101096       {
101097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101098       };
101099     }
101100   }
101101
101102 }
101103
101104 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
101105   Dali::RefObject *result = NULL;
101106
101107   if (arg1)
101108   {
101109     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
101110   }
101111   return result;
101112 }
101113
101114 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
101115     return (Dali::RefObject *)jarg1;
101116 }
101117
101118 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
101119     return (Dali::SignalObserver *)jarg1;
101120 }
101121
101122 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
101123     return (Dali::ConnectionTrackerInterface *)jarg1;
101124 }
101125
101126 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
101127     return (Dali::BaseHandle *)jarg1;
101128 }
101129
101130 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
101131     return (Dali::BaseHandle *)jarg1;
101132 }
101133
101134 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
101135     return (Dali::BaseHandle *)jarg1;
101136 }
101137
101138 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101139     return (Dali::BaseHandle *)jarg1;
101140 }
101141
101142 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101143     return (Dali::BaseHandle *)jarg1;
101144 }
101145
101146 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101147     return (Dali::BaseHandle *)jarg1;
101148 }
101149
101150 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101151     return (Dali::BaseHandle *)jarg1;
101152 }
101153
101154 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101155     return (Dali::BaseHandle *)jarg1;
101156 }
101157
101158 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101159     return (Dali::BaseHandle *)jarg1;
101160 }
101161
101162 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101163     return (Dali::BaseHandle *)jarg1;
101164 }
101165
101166 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101167     return (Dali::BaseHandle *)jarg1;
101168 }
101169
101170 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101171     return (Dali::BaseHandle *)jarg1;
101172 }
101173
101174 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101175     return (Dali::BaseHandle *)jarg1;
101176 }
101177
101178 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101179     return (Dali::Handle *)jarg1;
101180 }
101181
101182 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101183     return (Dali::Handle *)jarg1;
101184 }
101185
101186 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101187     return (Dali::BaseHandle *)jarg1;
101188 }
101189
101190 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101191     return (Dali::BaseHandle *)jarg1;
101192 }
101193
101194 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101195     return (Dali::Handle *)jarg1;
101196 }
101197
101198 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101199     return (Dali::BaseHandle *)jarg1;
101200 }
101201
101202 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101203     return (Dali::Handle *)jarg1;
101204 }
101205
101206 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101207     return (Dali::GestureDetector *)jarg1;
101208 }
101209
101210 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101211     return (Dali::Gesture *)jarg1;
101212 }
101213
101214 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101215     return (Dali::Handle *)jarg1;
101216 }
101217
101218 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101219     return (Dali::Actor *)jarg1;
101220 }
101221
101222 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101223     return (Dali::BaseHandle *)jarg1;
101224 }
101225
101226 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101227     return (Dali::RefObject *)jarg1;
101228 }
101229
101230 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101231     return (Dali::Actor *)jarg1;
101232 }
101233
101234 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101235     return (Dali::GestureDetector *)jarg1;
101236 }
101237
101238 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101239     return (Dali::Gesture *)jarg1;
101240 }
101241
101242 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101243     return (Dali::GestureDetector *)jarg1;
101244 }
101245
101246 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101247     return (Dali::Gesture *)jarg1;
101248 }
101249
101250 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101251     return (Dali::GestureDetector *)jarg1;
101252 }
101253
101254 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101255     return (Dali::Gesture *)jarg1;
101256 }
101257
101258 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101259     return (Dali::BaseHandle *)jarg1;
101260 }
101261
101262 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101263     return (Dali::Handle *)jarg1;
101264 }
101265
101266 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101267     return (Dali::Handle *)jarg1;
101268 }
101269
101270 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101271     return (Dali::Handle *)jarg1;
101272 }
101273
101274 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101275     return (Dali::Image *)jarg1;
101276 }
101277
101278 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101279     return (Dali::Image *)jarg1;
101280 }
101281
101282 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101283     return (Dali::Image *)jarg1;
101284 }
101285
101286 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101287     return (Dali::RefObject *)jarg1;
101288 }
101289
101290 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101291     return (Dali::Image *)jarg1;
101292 }
101293
101294 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101295     return (Dali::Image *)jarg1;
101296 }
101297
101298 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101299     return (Dali::ResourceImage *)jarg1;
101300 }
101301
101302 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101303     return (Dali::Actor *)jarg1;
101304 }
101305
101306 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101307     return (Dali::BaseHandle *)jarg1;
101308 }
101309
101310 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101311     return (Dali::BaseHandle *)jarg1;
101312 }
101313
101314
101315 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101316     return (Dali::BaseHandle *)jarg1;
101317 }
101318
101319 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101320     return (Dali::BaseHandle *)jarg1;
101321 }
101322
101323 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101324     return (Dali::CustomActorImpl *)jarg1;
101325 }
101326
101327 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101328     return (Dali::CustomActor *)jarg1;
101329 }
101330
101331 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101332     return (Dali::BaseHandle *)jarg1;
101333 }
101334
101335 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101336     return (Dali::Toolkit::Control *)jarg1;
101337 }
101338
101339 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101340     return (Dali::Toolkit::Control *)jarg1;
101341 }
101342
101343 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101344     return (Dali::Toolkit::Button *)jarg1;
101345 }
101346
101347 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101348     return (Dali::Toolkit::Button *)jarg1;
101349 }
101350
101351 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101352     return (Dali::Toolkit::Button *)jarg1;
101353 }
101354
101355 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101356     return (Dali::Toolkit::Control *)jarg1;
101357 }
101358
101359 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101360     return (Dali::Toolkit::Control *)jarg1;
101361 }
101362
101363 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101364     return (Dali::Toolkit::Control *)jarg1;
101365 }
101366
101367 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101368     return (Dali::Toolkit::Control *)jarg1;
101369 }
101370
101371 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101372     return (Dali::Toolkit::Control *)jarg1;
101373 }
101374
101375 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101376     return (Dali::RefObject *)jarg1;
101377 }
101378
101379 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101380     return (Dali::Toolkit::Scrollable *)jarg1;
101381 }
101382
101383 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101384     return (Dali::BaseHandle *)jarg1;
101385 }
101386
101387 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101388     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101389 }
101390
101391 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101392     return (Dali::RefObject *)jarg1;
101393 }
101394
101395 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101396     return (Dali::Toolkit::Ruler *)jarg1;
101397 }
101398
101399 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101400     return (Dali::Toolkit::Ruler *)jarg1;
101401 }
101402
101403 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101404     return (Dali::Toolkit::Scrollable *)jarg1;
101405 }
101406
101407 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101408     return (Dali::Toolkit::Control *)jarg1;
101409 }
101410
101411
101412 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101413     return (Dali::Toolkit::Control *)jarg1;
101414 }
101415
101416 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101417     return (Dali::BaseHandle *)jarg1;
101418 }
101419
101420 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101421     return (Dali::BaseHandle *)jarg1;
101422 }
101423
101424 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101425     return (Dali::Toolkit::Control *)jarg1;
101426 }
101427
101428 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101429     return (Dali::Toolkit::Control *)jarg1;
101430 }
101431
101432 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101433     return (Dali::Toolkit::Control *)jarg1;
101434 }
101435
101436 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101437     return (Dali::Toolkit::Control *)jarg1;
101438 }
101439
101440 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101441     return (Dali::Toolkit::Control *)jarg1;
101442 }
101443
101444 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101445     return (Dali::Toolkit::Control *)jarg1;
101446 }
101447
101448 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101449     return (Dali::Toolkit::PageTurnView *)jarg1;
101450 }
101451
101452 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101453     return (Dali::Toolkit::PageTurnView *)jarg1;
101454 }
101455
101456 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101457     return (Dali::Toolkit::Button *)jarg1;
101458 }
101459
101460 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101461     return (Dali::BaseHandle *)jarg1;
101462 }
101463
101464 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101465     return (Dali::BaseHandle *)jarg1;
101466 }
101467
101468 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101469     return (Dali::BaseHandle *)jarg1;
101470 }
101471
101472 /*
101473  * Widget binding
101474  */
101475 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101476     return (Dali::BaseHandle *)jarg1;
101477 }
101478
101479 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101480     return (Dali::BaseObject *)jarg1;
101481 }
101482
101483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101484   void * jresult ;
101485   Dali::Widget result;
101486
101487   {
101488     try {
101489       result = Dali::Widget::New();
101490     } catch (std::out_of_range& e) {
101491       {
101492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101493       };
101494     } catch (std::exception& e) {
101495       {
101496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101497       };
101498     } catch (...) {
101499       {
101500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101501       };
101502     }
101503   }
101504   jresult = new Dali::Widget((const Dali::Widget &)result);
101505   return jresult;
101506 }
101507
101508
101509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101510   void * jresult ;
101511   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101512   Dali::Widget result;
101513
101514   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101515
101516   if (!arg1) {
101517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101518     return 0;
101519   }
101520   {
101521     try {
101522       jresult = new Dali::Widget(arg1);
101523     } catch (std::out_of_range& e) {
101524       {
101525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101526       };
101527     } catch (std::exception& e) {
101528       {
101529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101530       };
101531     } catch (...) {
101532       {
101533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101534       };
101535     }
101536   }
101537   return jresult;
101538 }
101539
101540
101541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101542   void * jresult ;
101543   Dali::Widget *result = 0 ;
101544
101545   {
101546     try {
101547       result = (Dali::Widget *)new Dali::Widget();
101548     } catch (std::out_of_range& e) {
101549       {
101550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101551       };
101552     } catch (std::exception& e) {
101553       {
101554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101555       };
101556     } catch (...) {
101557       {
101558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101559       };
101560     }
101561   }
101562   jresult = (void *)result;
101563   return jresult;
101564 }
101565
101566
101567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101568   void * jresult ;
101569   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101570   Dali::Widget *arg2 = 0 ;
101571   Dali::Widget *result = 0 ;
101572
101573   arg1 = (Dali::Widget *)jarg1;
101574   arg2 = (Dali::Widget *)jarg2;
101575   if (!arg2) {
101576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101577     return 0;
101578   }
101579   {
101580     try {
101581       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101582     } catch (std::out_of_range& e) {
101583       {
101584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101585       };
101586     } catch (std::exception& e) {
101587       {
101588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101589       };
101590     } catch (...) {
101591       {
101592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101593       };
101594     }
101595   }
101596   jresult = (void *)result;
101597   return jresult;
101598 }
101599
101600
101601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101602   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101603
101604   arg1 = (Dali::Widget *)jarg1;
101605   {
101606     try {
101607       delete arg1;
101608     } catch (std::out_of_range& e) {
101609       {
101610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101611       };
101612     } catch (std::exception& e) {
101613       {
101614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101615       };
101616     } catch (...) {
101617       {
101618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101619       };
101620     }
101621   }
101622 }
101623
101624
101625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101626   void * jresult ;
101627   SwigDirector_WidgetImpl* result;
101628   {
101629     try {
101630       result = new SwigDirector_WidgetImpl();
101631     } catch (std::out_of_range& e) {
101632       {
101633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101634       };
101635     } catch (std::exception& e) {
101636       {
101637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101638       };
101639     } catch (...) {
101640       {
101641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101642       };
101643     }
101644   }
101645   jresult = result;
101646   return jresult;
101647 }
101648
101649
101650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101651   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101652   std::string *arg2 = 0 ;
101653   Dali::Window arg3 ;
101654   Dali::Window *argp3 ;
101655
101656   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101657   if (!jarg2) {
101658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101659     return ;
101660   }
101661   std::string arg2_str(jarg2);
101662   arg2 = &arg2_str;
101663   argp3 = (Dali::Window *)jarg3;
101664   if (!argp3) {
101665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101666     return ;
101667   }
101668   arg3 = *argp3;
101669   {
101670     try {
101671       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101672     } catch (std::out_of_range& e) {
101673       {
101674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101675       };
101676     } catch (std::exception& e) {
101677       {
101678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101679       };
101680     } catch (...) {
101681       {
101682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101683       };
101684     }
101685   }
101686 }
101687
101688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101689   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101690   std::string *arg2 = 0 ;
101691   Dali::Window arg3 ;
101692   Dali::Window *argp3 ;
101693
101694   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101695   if (!jarg2) {
101696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101697     return ;
101698   }
101699   std::string arg2_str(jarg2);
101700   arg2 = &arg2_str;
101701   argp3 = (Dali::Window *)jarg3;
101702   if (!argp3) {
101703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101704     return ;
101705   }
101706   arg3 = *argp3;
101707   {
101708     try {
101709       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101710     } catch (std::out_of_range& e) {
101711       {
101712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101713       };
101714     } catch (std::exception& e) {
101715       {
101716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101717       };
101718     } catch (...) {
101719       {
101720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101721       };
101722     }
101723   }
101724 }
101725
101726
101727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101728   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101729   std::string *arg2 = 0 ;
101730   Dali::Widget::Termination arg3 ;
101731
101732   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101733   if (!jarg2) {
101734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101735     return ;
101736   }
101737   std::string arg2_str(jarg2);
101738   arg2 = &arg2_str;
101739   arg3 = (Dali::Widget::Termination)jarg3;
101740   {
101741     try {
101742       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101743     } catch (std::out_of_range& e) {
101744       {
101745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101746       };
101747     } catch (std::exception& e) {
101748       {
101749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101750       };
101751     } catch (...) {
101752       {
101753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101754       };
101755     }
101756   }
101757 }
101758
101759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101760   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101761   std::string *arg2 = 0 ;
101762   Dali::Widget::Termination arg3 ;
101763
101764   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101765   if (!jarg2) {
101766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101767     return ;
101768   }
101769   std::string arg2_str(jarg2);
101770   arg2 = &arg2_str;
101771   arg3 = (Dali::Widget::Termination)jarg3;
101772   {
101773     try {
101774       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101775     } catch (std::out_of_range& e) {
101776       {
101777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101778       };
101779     } catch (std::exception& e) {
101780       {
101781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101782       };
101783     } catch (...) {
101784       {
101785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101786       };
101787     }
101788   }
101789 }
101790
101791
101792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101793   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101794
101795   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101796   {
101797     try {
101798       (arg1)->OnPause();
101799     } catch (std::out_of_range& e) {
101800       {
101801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101802       };
101803     } catch (std::exception& e) {
101804       {
101805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101806       };
101807     } catch (...) {
101808       {
101809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101810       };
101811     }
101812   }
101813 }
101814
101815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101816   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101817
101818   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101819   {
101820     try {
101821       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101822     } catch (std::out_of_range& e) {
101823       {
101824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101825       };
101826     } catch (std::exception& e) {
101827       {
101828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101829       };
101830     } catch (...) {
101831       {
101832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101833       };
101834     }
101835   }
101836 }
101837
101838
101839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101840   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101841
101842   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101843   {
101844     try {
101845       (arg1)->OnResume();
101846     } catch (std::out_of_range& e) {
101847       {
101848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101849       };
101850     } catch (std::exception& e) {
101851       {
101852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101853       };
101854     } catch (...) {
101855       {
101856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101857       };
101858     }
101859   }
101860 }
101861
101862
101863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101864   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101865
101866   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101867   {
101868     try {
101869       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101870     } catch (std::out_of_range& e) {
101871       {
101872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101873       };
101874     } catch (std::exception& e) {
101875       {
101876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101877       };
101878     } catch (...) {
101879       {
101880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101881       };
101882     }
101883   }
101884 }
101885
101886
101887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101888   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101889   Dali::Window arg2 ;
101890   Dali::Window *argp2 ;
101891
101892   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101893   argp2 = (Dali::Window *)jarg2;
101894   if (!argp2) {
101895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101896     return ;
101897   }
101898   arg2 = *argp2;
101899   {
101900     try {
101901       (arg1)->OnResize(arg2);
101902     } catch (std::out_of_range& e) {
101903       {
101904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101905       };
101906     } catch (std::exception& e) {
101907       {
101908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101909       };
101910     } catch (...) {
101911       {
101912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101913       };
101914     }
101915   }
101916 }
101917
101918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101919   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101920   Dali::Window arg2 ;
101921   Dali::Window *argp2 ;
101922
101923   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101924   argp2 = (Dali::Window *)jarg2;
101925   if (!argp2) {
101926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101927     return ;
101928   }
101929   arg2 = *argp2;
101930   {
101931     try {
101932       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101933     } catch (std::out_of_range& e) {
101934       {
101935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101936       };
101937     } catch (std::exception& e) {
101938       {
101939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101940       };
101941     } catch (...) {
101942       {
101943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101944       };
101945     }
101946   }
101947 }
101948
101949
101950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101951   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101952   std::string *arg2 = 0 ;
101953   int arg3 ;
101954
101955   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101956   if (!jarg2) {
101957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101958     return ;
101959   }
101960   std::string arg2_str(jarg2);
101961   arg2 = &arg2_str;
101962   arg3 = (int)jarg3;
101963   {
101964     try {
101965       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101966     } catch (std::out_of_range& e) {
101967       {
101968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101969       };
101970     } catch (std::exception& e) {
101971       {
101972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101973       };
101974     } catch (...) {
101975       {
101976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101977       };
101978     }
101979   }
101980 }
101981
101982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101983   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101984   std::string *arg2 = 0 ;
101985   int arg3 ;
101986
101987   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101988   if (!jarg2) {
101989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101990     return ;
101991   }
101992   std::string arg2_str(jarg2);
101993   arg2 = &arg2_str;
101994   arg3 = (int)jarg3;
101995   {
101996     try {
101997       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101998     } catch (std::out_of_range& e) {
101999       {
102000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102001       };
102002     } catch (std::exception& e) {
102003       {
102004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102005       };
102006     } catch (...) {
102007       {
102008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102009       };
102010     }
102011   }
102012 }
102013
102014
102015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
102016   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102017   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102018   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102019
102020   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102021   arg2 = (Dali::SlotObserver *)jarg2;
102022   arg3 = (Dali::CallbackBase *)jarg3;
102023   {
102024     try {
102025       (arg1)->SignalConnected(arg2,arg3);
102026     } catch (std::out_of_range& e) {
102027       {
102028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102029       };
102030     } catch (std::exception& e) {
102031       {
102032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102033       };
102034     } catch (...) {
102035       {
102036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102037       };
102038     }
102039   }
102040 }
102041
102042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102043   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102044   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102045   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102046
102047   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102048   arg2 = (Dali::SlotObserver *)jarg2;
102049   arg3 = (Dali::CallbackBase *)jarg3;
102050   {
102051     try {
102052       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
102053     } catch (std::out_of_range& e) {
102054       {
102055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102056       };
102057     } catch (std::exception& e) {
102058       {
102059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102060       };
102061     } catch (...) {
102062       {
102063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102064       };
102065     }
102066   }
102067 }
102068
102069
102070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
102071   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102072   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102073   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102074
102075   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102076   arg2 = (Dali::SlotObserver *)jarg2;
102077   arg3 = (Dali::CallbackBase *)jarg3;
102078   {
102079     try {
102080       (arg1)->SignalDisconnected(arg2,arg3);
102081     } catch (std::out_of_range& e) {
102082       {
102083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102084       };
102085     } catch (std::exception& e) {
102086       {
102087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102088       };
102089     } catch (...) {
102090       {
102091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102092       };
102093     }
102094   }
102095 }
102096
102097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102098   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102099   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102100   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102101
102102   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102103   arg2 = (Dali::SlotObserver *)jarg2;
102104   arg3 = (Dali::CallbackBase *)jarg3;
102105   {
102106     try {
102107       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
102108     } catch (std::out_of_range& e) {
102109       {
102110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102111       };
102112     } catch (std::exception& e) {
102113       {
102114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102115       };
102116     } catch (...) {
102117       {
102118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102119       };
102120     }
102121   }
102122 }
102123
102124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
102125   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102126   std::string *arg2 = 0 ;
102127
102128   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102129   if (!jarg2) {
102130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102131     return ;
102132   }
102133   std::string arg2_str(jarg2);
102134   arg2 = &arg2_str;
102135   {
102136     try {
102137       (arg1)->SetContentInfo((std::string const &)*arg2);
102138     } catch (std::out_of_range& e) {
102139       {
102140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102141       };
102142     } catch (std::exception& e) {
102143       {
102144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102145       };
102146     } catch (...) {
102147       {
102148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102149       };
102150     }
102151   }
102152 }
102153
102154
102155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102156   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102157   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102158
102159   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102160   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102161   {
102162     try {
102163       (arg1)->SetImpl(arg2);
102164     } catch (std::out_of_range& e) {
102165       {
102166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102167       };
102168     } catch (std::exception& e) {
102169       {
102170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102171       };
102172     } catch (...) {
102173       {
102174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102175       };
102176     }
102177   }
102178 }
102179
102180 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) {
102181
102182   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102183   if (director) {
102184     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102185   }
102186 }
102187
102188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102189   void * jresult ;
102190   Dali::Widget *arg1 = 0 ;
102191   SwigDirector_WidgetImpl *result = 0 ;
102192
102193   arg1 = (Dali::Widget *)jarg1;
102194   if (!arg1) {
102195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102196     return 0;
102197   }
102198   {
102199     try {
102200       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
102201     } catch (std::out_of_range& e) {
102202       {
102203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102204       };
102205     } catch (std::exception& e) {
102206       {
102207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102208       };
102209     } catch (...) {
102210       {
102211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102212       };
102213     }
102214   }
102215
102216   jresult = (void *)result;
102217   return jresult;
102218 }
102219
102220
102221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102222   void * jresult ;
102223   int *arg1 = (int *) 0 ;
102224   char ***arg2 ;
102225   std::string *arg3 = 0 ;
102226   Dali::WidgetApplication result;
102227   {
102228     int index = 0;
102229     int length = 0;
102230     char *retPtr;
102231     char *nextPtr;
102232     argWidgetC = jarg1;
102233     argWidgetV = new char*[jarg1 + 1];
102234
102235     retPtr = strtok_r( jarg2, " ", &nextPtr);
102236     if( retPtr )
102237     {
102238       length = strlen(retPtr);
102239     }
102240     argWidgetV[index] = new char[length + 1];
102241     if( retPtr )
102242     {
102243       strncpy(argWidgetV[index], retPtr, length);
102244     }
102245     argWidgetV[index][length] = '\0';
102246     index++;
102247
102248     while (index < jarg1)
102249     {
102250       length = 0;
102251       retPtr = strtok_r(NULL, " ", &nextPtr);
102252       if( retPtr )
102253       {
102254         length = strlen(retPtr);
102255       }
102256       argWidgetV[index] = new char[length + 1];
102257       if( retPtr )
102258       {
102259         strncpy(argWidgetV[index], retPtr, length);
102260       }
102261       argWidgetV[index][length] = '\0';
102262       index++;
102263     }
102264
102265     argWidgetV[jarg1] = NULL;
102266     argWidgetC = jarg1;
102267
102268     arg1 = &argWidgetC;
102269     arg2 = &argWidgetV;
102270   }
102271
102272   if (!jarg3) {
102273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102274     return 0;
102275   }
102276   std::string arg3_str(jarg3);
102277   arg3 = &arg3_str;
102278   {
102279     try {
102280       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102281     } catch (std::out_of_range& e) {
102282       {
102283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102284       };
102285     } catch (std::exception& e) {
102286       {
102287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102288       };
102289     } catch (...) {
102290       {
102291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102292       };
102293     }
102294   }
102295   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102296
102297   return jresult;
102298 }
102299
102300
102301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102302   void * jresult ;
102303   Dali::WidgetApplication *result = 0 ;
102304
102305   {
102306     try {
102307       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102308     } catch (std::out_of_range& e) {
102309       {
102310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102311       };
102312     } catch (std::exception& e) {
102313       {
102314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102315       };
102316     } catch (...) {
102317       {
102318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102319       };
102320     }
102321   }
102322   jresult = (void *)result;
102323   return jresult;
102324 }
102325
102326
102327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102328   void * jresult ;
102329   Dali::WidgetApplication *arg1 = 0 ;
102330   Dali::WidgetApplication *result = 0 ;
102331
102332   arg1 = (Dali::WidgetApplication *)jarg1;
102333   if (!arg1) {
102334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102335     return 0;
102336   }
102337   {
102338     try {
102339       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
102340     } catch (std::out_of_range& e) {
102341       {
102342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102343       };
102344     } catch (std::exception& e) {
102345       {
102346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102347       };
102348     } catch (...) {
102349       {
102350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102351       };
102352     }
102353   }
102354   jresult = (void *)result;
102355   return jresult;
102356 }
102357
102358
102359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102360   void * jresult ;
102361   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102362   Dali::WidgetApplication *arg2 = 0 ;
102363   Dali::WidgetApplication *result = 0 ;
102364
102365   arg1 = (Dali::WidgetApplication *)jarg1;
102366   arg2 = (Dali::WidgetApplication *)jarg2;
102367   if (!arg2) {
102368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102369     return 0;
102370   }
102371   {
102372     try {
102373       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102374     } catch (std::out_of_range& e) {
102375       {
102376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102377       };
102378     } catch (std::exception& e) {
102379       {
102380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102381       };
102382     } catch (...) {
102383       {
102384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102385       };
102386     }
102387   }
102388   jresult = (void *)result;
102389   return jresult;
102390 }
102391
102392
102393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102394   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102395
102396   arg1 = (Dali::WidgetApplication *)jarg1;
102397   {
102398     try {
102399       delete arg1;
102400       if( argWidgetV )
102401       {
102402         // free string data
102403         for( int i=0; i < argWidgetC+1; i++)
102404         {
102405           delete [] argWidgetV[i];
102406         }
102407         delete [] argWidgetV;
102408       }
102409     } catch (std::out_of_range& e) {
102410       {
102411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102412       };
102413     } catch (std::exception& e) {
102414       {
102415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102416       };
102417     } catch (...) {
102418       {
102419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102420       };
102421     }
102422   }
102423 }
102424
102425
102426 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102427 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102428
102429 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102430 {
102431   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102432   return *widget;
102433 }
102434
102435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102436   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102437   std::string *arg2 = 0 ;
102438
102439   arg1 = (Dali::WidgetApplication *)jarg1;
102440   if (!jarg2) {
102441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102442     return ;
102443   }
102444   std::string arg2_str(*jarg2);
102445   arg2 = &arg2_str;
102446
102447   if(!_CSharpCreateWidgetFunction)
102448   {
102449     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102450   }
102451
102452   {
102453     try {
102454       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102455     } catch (std::out_of_range& e) {
102456       {
102457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102458       };
102459     } catch (std::exception& e) {
102460       {
102461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102462       };
102463     } catch (...) {
102464       {
102465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102466       };
102467     }
102468   }
102469
102470   //Typemap argout in c++ file.
102471   //This will convert c++ string to c# string
102472   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102473 }
102474
102475
102476 //for PixelBuffer and ImageLoading
102477
102478 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102479     return (Dali::BaseHandle *)jarg1;
102480 }
102481
102482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102483   void * jresult ;
102484   unsigned int arg1 ;
102485   unsigned int arg2 ;
102486   Dali::Pixel::Format arg3 ;
102487   Dali::Devel::PixelBuffer result;
102488
102489   arg1 = (unsigned int)jarg1;
102490   arg2 = (unsigned int)jarg2;
102491   arg3 = (Dali::Pixel::Format)jarg3;
102492   {
102493     try {
102494       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102495     } catch (std::out_of_range& e) {
102496       {
102497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102498       };
102499     } catch (std::exception& e) {
102500       {
102501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102502       };
102503     } catch (...) {
102504       {
102505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102506       };
102507     }
102508   }
102509   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102510   return jresult;
102511 }
102512
102513
102514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102515   void * jresult ;
102516   Dali::Devel::PixelBuffer *result = 0 ;
102517
102518   {
102519     try {
102520       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102521     } catch (std::out_of_range& e) {
102522       {
102523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102524       };
102525     } catch (std::exception& e) {
102526       {
102527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102528       };
102529     } catch (...) {
102530       {
102531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102532       };
102533     }
102534   }
102535   jresult = (void *)result;
102536   return jresult;
102537 }
102538
102539
102540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102541   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102542
102543   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102544   {
102545     try {
102546       delete arg1;
102547     } catch (std::out_of_range& e) {
102548       {
102549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102550       };
102551     } catch (std::exception& e) {
102552       {
102553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102554       };
102555     } catch (...) {
102556       {
102557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102558       };
102559     }
102560   }
102561 }
102562
102563
102564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102565   void * jresult ;
102566   Dali::Devel::PixelBuffer *arg1 = 0 ;
102567   Dali::Devel::PixelBuffer *result = 0 ;
102568
102569   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102570   if (!arg1) {
102571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102572     return 0;
102573   }
102574   {
102575     try {
102576       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102577     } catch (std::out_of_range& e) {
102578       {
102579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102580       };
102581     } catch (std::exception& e) {
102582       {
102583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102584       };
102585     } catch (...) {
102586       {
102587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102588       };
102589     }
102590   }
102591   jresult = (void *)result;
102592   return jresult;
102593 }
102594
102595
102596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102597   void * jresult ;
102598   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102599   Dali::Devel::PixelBuffer *arg2 = 0 ;
102600   Dali::Devel::PixelBuffer *result = 0 ;
102601
102602   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102603   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102604   if (!arg2) {
102605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102606     return 0;
102607   }
102608   {
102609     try {
102610       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102611     } catch (std::out_of_range& e) {
102612       {
102613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102614       };
102615     } catch (std::exception& e) {
102616       {
102617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102618       };
102619     } catch (...) {
102620       {
102621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102622       };
102623     }
102624   }
102625   jresult = (void *)result;
102626   return jresult;
102627 }
102628
102629
102630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102631   void * jresult ;
102632   Dali::Devel::PixelBuffer *arg1 = 0 ;
102633   Dali::PixelData result;
102634
102635   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102636   if (!arg1) {
102637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102638     return 0;
102639   }
102640   {
102641     try {
102642       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102643     } catch (std::out_of_range& e) {
102644       {
102645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102646       };
102647     } catch (std::exception& e) {
102648       {
102649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102650       };
102651     } catch (...) {
102652       {
102653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102654       };
102655     }
102656   }
102657   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102658   return jresult;
102659 }
102660
102661
102662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102663   void * jresult ;
102664   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102665   Dali::PixelData result;
102666
102667   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102668   {
102669     try {
102670       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102671     } catch (std::out_of_range& e) {
102672       {
102673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102674       };
102675     } catch (std::exception& e) {
102676       {
102677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102678       };
102679     } catch (...) {
102680       {
102681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102682       };
102683     }
102684   }
102685   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102686   return jresult;
102687 }
102688
102689
102690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102691   void * jresult ;
102692   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102693   unsigned char *result = 0 ;
102694
102695   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102696   {
102697     try {
102698       result = (unsigned char *)(arg1)->GetBuffer();
102699     } catch (std::out_of_range& e) {
102700       {
102701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102702       };
102703     } catch (std::exception& e) {
102704       {
102705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102706       };
102707     } catch (...) {
102708       {
102709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102710       };
102711     }
102712   }
102713   jresult = (void *)result;
102714   return jresult;
102715 }
102716
102717
102718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102719   unsigned int jresult ;
102720   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102721   unsigned int result;
102722
102723   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102724   {
102725     try {
102726       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102727     } catch (std::out_of_range& e) {
102728       {
102729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102730       };
102731     } catch (std::exception& e) {
102732       {
102733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102734       };
102735     } catch (...) {
102736       {
102737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102738       };
102739     }
102740   }
102741   jresult = result;
102742   return jresult;
102743 }
102744
102745
102746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102747   unsigned int jresult ;
102748   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102749   unsigned int result;
102750
102751   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102752   {
102753     try {
102754       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102755     } catch (std::out_of_range& e) {
102756       {
102757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102758       };
102759     } catch (std::exception& e) {
102760       {
102761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102762       };
102763     } catch (...) {
102764       {
102765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102766       };
102767     }
102768   }
102769   jresult = result;
102770   return jresult;
102771 }
102772
102773
102774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102775   int jresult ;
102776   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102777   Dali::Pixel::Format result;
102778
102779   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102780   {
102781     try {
102782       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102783     } catch (std::out_of_range& e) {
102784       {
102785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102786       };
102787     } catch (std::exception& e) {
102788       {
102789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102790       };
102791     } catch (...) {
102792       {
102793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102794       };
102795     }
102796   }
102797   jresult = (int)result;
102798   return jresult;
102799 }
102800
102801
102802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102803   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102804   Dali::Devel::PixelBuffer arg2 ;
102805   float arg3 ;
102806   bool arg4 ;
102807   Dali::Devel::PixelBuffer *argp2 ;
102808
102809   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102810   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102811   if (!argp2) {
102812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102813     return ;
102814   }
102815   arg2 = *argp2;
102816   arg3 = (float)jarg3;
102817   arg4 = jarg4 ? true : false;
102818   {
102819     try {
102820       (arg1)->ApplyMask(arg2,arg3,arg4);
102821     } catch (std::out_of_range& e) {
102822       {
102823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102824       };
102825     } catch (std::exception& e) {
102826       {
102827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102828       };
102829     } catch (...) {
102830       {
102831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102832       };
102833     }
102834   }
102835 }
102836
102837
102838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102839   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102840   Dali::Devel::PixelBuffer arg2 ;
102841   float arg3 ;
102842   Dali::Devel::PixelBuffer *argp2 ;
102843
102844   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102845   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102846   if (!argp2) {
102847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102848     return ;
102849   }
102850   arg2 = *argp2;
102851   arg3 = (float)jarg3;
102852   {
102853     try {
102854       (arg1)->ApplyMask(arg2,arg3);
102855     } catch (std::out_of_range& e) {
102856       {
102857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102858       };
102859     } catch (std::exception& e) {
102860       {
102861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102862       };
102863     } catch (...) {
102864       {
102865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102866       };
102867     }
102868   }
102869 }
102870
102871
102872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102873   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102874   Dali::Devel::PixelBuffer arg2 ;
102875   Dali::Devel::PixelBuffer *argp2 ;
102876
102877   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102878   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102879   if (!argp2) {
102880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102881     return ;
102882   }
102883   arg2 = *argp2;
102884   {
102885     try {
102886       (arg1)->ApplyMask(arg2);
102887     } catch (std::out_of_range& e) {
102888       {
102889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102890       };
102891     } catch (std::exception& e) {
102892       {
102893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102894       };
102895     } catch (...) {
102896       {
102897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102898       };
102899     }
102900   }
102901 }
102902
102903
102904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102905   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102906   float arg2 ;
102907
102908   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102909   arg2 = (float)jarg2;
102910   {
102911     try {
102912       (arg1)->ApplyGaussianBlur(arg2);
102913     } catch (std::out_of_range& e) {
102914       {
102915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102916       };
102917     } catch (std::exception& e) {
102918       {
102919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102920       };
102921     } catch (...) {
102922       {
102923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102924       };
102925     }
102926   }
102927 }
102928
102929
102930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102931   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102932   uint16_t arg2 ;
102933   uint16_t arg3 ;
102934   uint16_t arg4 ;
102935   uint16_t arg5 ;
102936
102937   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102938   arg2 = (uint16_t)jarg2;
102939   arg3 = (uint16_t)jarg3;
102940   arg4 = (uint16_t)jarg4;
102941   arg5 = (uint16_t)jarg5;
102942   {
102943     try {
102944       (arg1)->Crop(arg2,arg3,arg4,arg5);
102945     } catch (std::out_of_range& e) {
102946       {
102947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102948       };
102949     } catch (std::exception& e) {
102950       {
102951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102952       };
102953     } catch (...) {
102954       {
102955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102956       };
102957     }
102958   }
102959 }
102960
102961
102962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102963   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102964   uint16_t arg2 ;
102965   uint16_t arg3 ;
102966
102967   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102968   arg2 = (uint16_t)jarg2;
102969   arg3 = (uint16_t)jarg3;
102970   {
102971     try {
102972       (arg1)->Resize(arg2,arg3);
102973     } catch (std::out_of_range& e) {
102974       {
102975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102976       };
102977     } catch (std::exception& e) {
102978       {
102979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102980       };
102981     } catch (...) {
102982       {
102983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102984       };
102985     }
102986   }
102987 }
102988
102989
102990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102991   void * jresult ;
102992   std::string *arg1 = 0 ;
102993   Dali::ImageDimensions arg2 ;
102994   Dali::FittingMode::Type arg3 ;
102995   Dali::SamplingMode::Type arg4 ;
102996   bool arg5 ;
102997   Dali::ImageDimensions *argp2 ;
102998   Dali::Devel::PixelBuffer result;
102999
103000   if (!jarg1) {
103001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103002     return 0;
103003   }
103004   std::string arg1_str(jarg1);
103005   arg1 = &arg1_str;
103006   argp2 = (Dali::ImageDimensions *)jarg2;
103007   if (!argp2) {
103008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103009     return 0;
103010   }
103011   arg2 = *argp2;
103012   arg3 = (Dali::FittingMode::Type)jarg3;
103013   arg4 = (Dali::SamplingMode::Type)jarg4;
103014   arg5 = jarg5 ? true : false;
103015   {
103016     try {
103017       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103018     } catch (std::out_of_range& e) {
103019       {
103020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103021       };
103022     } catch (std::exception& e) {
103023       {
103024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103025       };
103026     } catch (...) {
103027       {
103028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103029       };
103030     }
103031   }
103032   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103033
103034   return jresult;
103035 }
103036
103037
103038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103039   void * jresult ;
103040   std::string *arg1 = 0 ;
103041   Dali::ImageDimensions arg2 ;
103042   Dali::FittingMode::Type arg3 ;
103043   Dali::SamplingMode::Type arg4 ;
103044   Dali::ImageDimensions *argp2 ;
103045   Dali::Devel::PixelBuffer result;
103046
103047   if (!jarg1) {
103048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103049     return 0;
103050   }
103051   std::string arg1_str(jarg1);
103052   arg1 = &arg1_str;
103053   argp2 = (Dali::ImageDimensions *)jarg2;
103054   if (!argp2) {
103055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103056     return 0;
103057   }
103058   arg2 = *argp2;
103059   arg3 = (Dali::FittingMode::Type)jarg3;
103060   arg4 = (Dali::SamplingMode::Type)jarg4;
103061   {
103062     try {
103063       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
103064     } catch (std::out_of_range& e) {
103065       {
103066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103067       };
103068     } catch (std::exception& e) {
103069       {
103070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103071       };
103072     } catch (...) {
103073       {
103074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103075       };
103076     }
103077   }
103078   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103079
103080   return jresult;
103081 }
103082
103083
103084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103085   void * jresult ;
103086   std::string *arg1 = 0 ;
103087   Dali::ImageDimensions arg2 ;
103088   Dali::FittingMode::Type arg3 ;
103089   Dali::ImageDimensions *argp2 ;
103090   Dali::Devel::PixelBuffer result;
103091
103092   if (!jarg1) {
103093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103094     return 0;
103095   }
103096   std::string arg1_str(jarg1);
103097   arg1 = &arg1_str;
103098   argp2 = (Dali::ImageDimensions *)jarg2;
103099   if (!argp2) {
103100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103101     return 0;
103102   }
103103   arg2 = *argp2;
103104   arg3 = (Dali::FittingMode::Type)jarg3;
103105   {
103106     try {
103107       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
103108     } catch (std::out_of_range& e) {
103109       {
103110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103111       };
103112     } catch (std::exception& e) {
103113       {
103114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103115       };
103116     } catch (...) {
103117       {
103118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103119       };
103120     }
103121   }
103122   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103123
103124   return jresult;
103125 }
103126
103127
103128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
103129   void * jresult ;
103130   std::string *arg1 = 0 ;
103131   Dali::ImageDimensions arg2 ;
103132   Dali::ImageDimensions *argp2 ;
103133   Dali::Devel::PixelBuffer result;
103134
103135   if (!jarg1) {
103136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103137     return 0;
103138   }
103139   std::string arg1_str(jarg1);
103140   arg1 = &arg1_str;
103141   argp2 = (Dali::ImageDimensions *)jarg2;
103142   if (!argp2) {
103143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103144     return 0;
103145   }
103146   arg2 = *argp2;
103147   {
103148     try {
103149       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103150     } catch (std::out_of_range& e) {
103151       {
103152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103153       };
103154     } catch (std::exception& e) {
103155       {
103156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103157       };
103158     } catch (...) {
103159       {
103160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103161       };
103162     }
103163   }
103164   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103165
103166   return jresult;
103167 }
103168
103169
103170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103171   void * jresult ;
103172   std::string *arg1 = 0 ;
103173   Dali::Devel::PixelBuffer result;
103174
103175   if (!jarg1) {
103176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103177     return 0;
103178   }
103179   std::string arg1_str(jarg1);
103180   arg1 = &arg1_str;
103181   {
103182     try {
103183       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103184     } catch (std::out_of_range& e) {
103185       {
103186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103187       };
103188     } catch (std::exception& e) {
103189       {
103190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103191       };
103192     } catch (...) {
103193       {
103194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103195       };
103196     }
103197   }
103198   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103199
103200   return jresult;
103201 }
103202
103203
103204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103205   void * jresult ;
103206   std::string *arg1 = 0 ;
103207   Dali::ImageDimensions arg2 ;
103208   Dali::FittingMode::Type arg3 ;
103209   Dali::SamplingMode::Type arg4 ;
103210   bool arg5 ;
103211   Dali::ImageDimensions *argp2 ;
103212   Dali::ImageDimensions result;
103213
103214   if (!jarg1) {
103215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103216     return 0;
103217   }
103218   std::string arg1_str(jarg1);
103219   arg1 = &arg1_str;
103220   argp2 = (Dali::ImageDimensions *)jarg2;
103221   if (!argp2) {
103222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103223     return 0;
103224   }
103225   arg2 = *argp2;
103226   arg3 = (Dali::FittingMode::Type)jarg3;
103227   arg4 = (Dali::SamplingMode::Type)jarg4;
103228   arg5 = jarg5 ? true : false;
103229   {
103230     try {
103231       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103232     } catch (std::out_of_range& e) {
103233       {
103234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103235       };
103236     } catch (std::exception& e) {
103237       {
103238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103239       };
103240     } catch (...) {
103241       {
103242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103243       };
103244     }
103245   }
103246   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103247
103248   return jresult;
103249 }
103250
103251
103252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103253   void * jresult ;
103254   std::string *arg1 = 0 ;
103255   Dali::ImageDimensions arg2 ;
103256   Dali::FittingMode::Type arg3 ;
103257   Dali::SamplingMode::Type arg4 ;
103258   Dali::ImageDimensions *argp2 ;
103259   Dali::ImageDimensions result;
103260
103261   if (!jarg1) {
103262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103263     return 0;
103264   }
103265   std::string arg1_str(jarg1);
103266   arg1 = &arg1_str;
103267   argp2 = (Dali::ImageDimensions *)jarg2;
103268   if (!argp2) {
103269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103270     return 0;
103271   }
103272   arg2 = *argp2;
103273   arg3 = (Dali::FittingMode::Type)jarg3;
103274   arg4 = (Dali::SamplingMode::Type)jarg4;
103275   {
103276     try {
103277       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103278     } catch (std::out_of_range& e) {
103279       {
103280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103281       };
103282     } catch (std::exception& e) {
103283       {
103284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103285       };
103286     } catch (...) {
103287       {
103288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103289       };
103290     }
103291   }
103292   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103293
103294   return jresult;
103295 }
103296
103297
103298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103299   void * jresult ;
103300   std::string *arg1 = 0 ;
103301   Dali::ImageDimensions arg2 ;
103302   Dali::FittingMode::Type arg3 ;
103303   Dali::ImageDimensions *argp2 ;
103304   Dali::ImageDimensions result;
103305
103306   if (!jarg1) {
103307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103308     return 0;
103309   }
103310   std::string arg1_str(jarg1);
103311   arg1 = &arg1_str;
103312   argp2 = (Dali::ImageDimensions *)jarg2;
103313   if (!argp2) {
103314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103315     return 0;
103316   }
103317   arg2 = *argp2;
103318   arg3 = (Dali::FittingMode::Type)jarg3;
103319   {
103320     try {
103321       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103322     } catch (std::out_of_range& e) {
103323       {
103324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103325       };
103326     } catch (std::exception& e) {
103327       {
103328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103329       };
103330     } catch (...) {
103331       {
103332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103333       };
103334     }
103335   }
103336   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103337
103338   return jresult;
103339 }
103340
103341
103342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103343   void * jresult ;
103344   std::string *arg1 = 0 ;
103345   Dali::ImageDimensions arg2 ;
103346   Dali::ImageDimensions *argp2 ;
103347   Dali::ImageDimensions result;
103348
103349   if (!jarg1) {
103350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103351     return 0;
103352   }
103353   std::string arg1_str(jarg1);
103354   arg1 = &arg1_str;
103355   argp2 = (Dali::ImageDimensions *)jarg2;
103356   if (!argp2) {
103357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103358     return 0;
103359   }
103360   arg2 = *argp2;
103361   {
103362     try {
103363       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103364     } catch (std::out_of_range& e) {
103365       {
103366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103367       };
103368     } catch (std::exception& e) {
103369       {
103370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103371       };
103372     } catch (...) {
103373       {
103374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103375       };
103376     }
103377   }
103378   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103379
103380   return jresult;
103381 }
103382
103383
103384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103385   void * jresult ;
103386   std::string *arg1 = 0 ;
103387   Dali::ImageDimensions result;
103388
103389   if (!jarg1) {
103390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103391     return 0;
103392   }
103393   std::string arg1_str(jarg1);
103394   arg1 = &arg1_str;
103395   {
103396     try {
103397       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103398     } catch (std::out_of_range& e) {
103399       {
103400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103401       };
103402     } catch (std::exception& e) {
103403       {
103404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103405       };
103406     } catch (...) {
103407       {
103408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103409       };
103410     }
103411   }
103412   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103413
103414   return jresult;
103415 }
103416
103417
103418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103419   void * jresult ;
103420   std::string *arg1 = 0 ;
103421   Dali::ImageDimensions arg2 ;
103422   Dali::FittingMode::Type arg3 ;
103423   Dali::SamplingMode::Type arg4 ;
103424   bool arg5 ;
103425   Dali::ImageDimensions *argp2 ;
103426   Dali::Devel::PixelBuffer result;
103427
103428   if (!jarg1) {
103429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103430     return 0;
103431   }
103432   std::string arg1_str(jarg1);
103433   arg1 = &arg1_str;
103434   argp2 = (Dali::ImageDimensions *)jarg2;
103435   if (!argp2) {
103436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103437     return 0;
103438   }
103439   arg2 = *argp2;
103440   arg3 = (Dali::FittingMode::Type)jarg3;
103441   arg4 = (Dali::SamplingMode::Type)jarg4;
103442   arg5 = jarg5 ? true : false;
103443   {
103444     try {
103445       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103446     } catch (std::out_of_range& e) {
103447       {
103448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103449       };
103450     } catch (std::exception& e) {
103451       {
103452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103453       };
103454     } catch (...) {
103455       {
103456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103457       };
103458     }
103459   }
103460   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103461
103462   return jresult;
103463 }
103464
103465
103466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103467   void * jresult ;
103468   std::string *arg1 = 0 ;
103469   Dali::ImageDimensions arg2 ;
103470   Dali::FittingMode::Type arg3 ;
103471   Dali::SamplingMode::Type arg4 ;
103472   Dali::ImageDimensions *argp2 ;
103473   Dali::Devel::PixelBuffer result;
103474
103475   if (!jarg1) {
103476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103477     return 0;
103478   }
103479   std::string arg1_str(jarg1);
103480   arg1 = &arg1_str;
103481   argp2 = (Dali::ImageDimensions *)jarg2;
103482   if (!argp2) {
103483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103484     return 0;
103485   }
103486   arg2 = *argp2;
103487   arg3 = (Dali::FittingMode::Type)jarg3;
103488   arg4 = (Dali::SamplingMode::Type)jarg4;
103489   {
103490     try {
103491       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103492     } catch (std::out_of_range& e) {
103493       {
103494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103495       };
103496     } catch (std::exception& e) {
103497       {
103498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103499       };
103500     } catch (...) {
103501       {
103502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103503       };
103504     }
103505   }
103506   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103507
103508   return jresult;
103509 }
103510
103511
103512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103513   void * jresult ;
103514   std::string *arg1 = 0 ;
103515   Dali::ImageDimensions arg2 ;
103516   Dali::FittingMode::Type arg3 ;
103517   Dali::ImageDimensions *argp2 ;
103518   Dali::Devel::PixelBuffer result;
103519
103520   if (!jarg1) {
103521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103522     return 0;
103523   }
103524   std::string arg1_str(jarg1);
103525   arg1 = &arg1_str;
103526   argp2 = (Dali::ImageDimensions *)jarg2;
103527   if (!argp2) {
103528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103529     return 0;
103530   }
103531   arg2 = *argp2;
103532   arg3 = (Dali::FittingMode::Type)jarg3;
103533   {
103534     try {
103535       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103536     } catch (std::out_of_range& e) {
103537       {
103538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103539       };
103540     } catch (std::exception& e) {
103541       {
103542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103543       };
103544     } catch (...) {
103545       {
103546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103547       };
103548     }
103549   }
103550   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103551
103552   return jresult;
103553 }
103554
103555
103556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103557   void * jresult ;
103558   std::string *arg1 = 0 ;
103559   Dali::ImageDimensions arg2 ;
103560   Dali::ImageDimensions *argp2 ;
103561   Dali::Devel::PixelBuffer result;
103562
103563   if (!jarg1) {
103564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103565     return 0;
103566   }
103567   std::string arg1_str(jarg1);
103568   arg1 = &arg1_str;
103569   argp2 = (Dali::ImageDimensions *)jarg2;
103570   if (!argp2) {
103571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103572     return 0;
103573   }
103574   arg2 = *argp2;
103575   {
103576     try {
103577       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103578     } catch (std::out_of_range& e) {
103579       {
103580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103581       };
103582     } catch (std::exception& e) {
103583       {
103584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103585       };
103586     } catch (...) {
103587       {
103588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103589       };
103590     }
103591   }
103592   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103593
103594   return jresult;
103595 }
103596
103597
103598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103599   void * jresult ;
103600   std::string *arg1 = 0 ;
103601   Dali::Devel::PixelBuffer result;
103602
103603   if (!jarg1) {
103604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103605     return 0;
103606   }
103607   std::string arg1_str(jarg1);
103608   arg1 = &arg1_str;
103609   {
103610     try {
103611       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103612     } catch (std::out_of_range& e) {
103613       {
103614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103615       };
103616     } catch (std::exception& e) {
103617       {
103618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103619       };
103620     } catch (...) {
103621       {
103622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103623       };
103624     }
103625   }
103626   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103627
103628   return jresult;
103629 }
103630
103631
103632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
103633   void * jresult ;
103634   Dali::Toolkit::WebView result;
103635
103636   {
103637     try {
103638       result = Dali::Toolkit::WebView::New();
103639     } catch (std::out_of_range& e) {
103640       {
103641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103642       };
103643     } catch (std::exception& e) {
103644       {
103645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103646       };
103647     } catch (Dali::DaliException e) {
103648       {
103649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103650       };
103651     } catch (...) {
103652       {
103653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103654       };
103655     }
103656   }
103657   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103658   return jresult;
103659 }
103660
103661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
103662   void * jresult ;
103663   Dali::Toolkit::WebView result;
103664
103665   std::string *arg1;
103666   std::string *arg2;
103667
103668   if (!jarg1) {
103669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
103670     return 0;
103671   }
103672   if (!jarg2) {
103673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
103674     return 0;
103675   }
103676
103677   std::string jarg1_str = std::string(jarg1);
103678   std::string jarg2_str = std::string(jarg2);
103679
103680   arg1 = &jarg1_str;
103681   arg2 = &jarg2_str;
103682
103683   {
103684     try {
103685       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
103686     } catch (std::out_of_range& e) {
103687       {
103688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103689       };
103690     } catch (std::exception& e) {
103691       {
103692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103693       };
103694     } catch (Dali::DaliException e) {
103695       {
103696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103697       };
103698     } catch (...) {
103699       {
103700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103701       };
103702     }
103703   }
103704   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103705   return jresult;
103706 }
103707
103708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
103709   void * jresult ;
103710   Dali::Toolkit::WebView *arg1 = 0 ;
103711   Dali::Toolkit::WebView *result = 0 ;
103712
103713   arg1 = (Dali::Toolkit::WebView *)jarg1;
103714   if (!arg1) {
103715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103716     return 0;
103717   }
103718   {
103719     try {
103720       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
103721     } catch (std::out_of_range& e) {
103722       {
103723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103724       };
103725     } catch (std::exception& e) {
103726       {
103727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103728       };
103729     } catch (Dali::DaliException e) {
103730       {
103731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103732       };
103733     } catch (...) {
103734       {
103735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103736       };
103737     }
103738   }
103739   jresult = (void *)result;
103740   return jresult;
103741 }
103742
103743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
103744   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103745   arg1 = (Dali::Toolkit::WebView *)jarg1;
103746   {
103747     try {
103748       delete arg1;
103749     } catch (std::out_of_range& e) {
103750       {
103751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103752       };
103753     } catch (std::exception& e) {
103754       {
103755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103756       };
103757     } catch (Dali::DaliException e) {
103758       {
103759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103760       };
103761     } catch (...) {
103762       {
103763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103764       };
103765     }
103766   }
103767 }
103768
103769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103770   void * jresult ;
103771   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103772   Dali::Toolkit::WebView *arg2 = 0 ;
103773   Dali::Toolkit::WebView *result = 0 ;
103774
103775   arg1 = (Dali::Toolkit::WebView *)jarg1;
103776   arg2 = (Dali::Toolkit::WebView *)jarg2;
103777   if (!arg2) {
103778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103779     return 0;
103780   }
103781   {
103782     try {
103783       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103784     } catch (std::out_of_range& e) {
103785       {
103786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103787       };
103788     } catch (std::exception& e) {
103789       {
103790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103791       };
103792     } catch (Dali::DaliException e) {
103793       {
103794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103795       };
103796     } catch (...) {
103797       {
103798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103799       };
103800     }
103801   }
103802   jresult = (void *)result;
103803   return jresult;
103804 }
103805
103806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103807   void * jresult ;
103808   Dali::BaseHandle arg1 ;
103809   Dali::BaseHandle *argp1 ;
103810   Dali::Toolkit::WebView result;
103811
103812   argp1 = (Dali::BaseHandle *)jarg1;
103813   if (!argp1) {
103814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103815     return 0;
103816   }
103817   arg1 = *argp1;
103818   {
103819     try {
103820       result = Dali::Toolkit::WebView::DownCast(arg1);
103821     } catch (std::out_of_range& e) {
103822       {
103823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103824       };
103825     } catch (std::exception& e) {
103826       {
103827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103828       };
103829     } catch (Dali::DaliException e) {
103830       {
103831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103832       };
103833     } catch (...) {
103834       {
103835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103836       };
103837     }
103838   }
103839   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103840   return jresult;
103841 }
103842
103843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103844   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103845   std::string *arg2;
103846
103847   arg1 = (Dali::Toolkit::WebView *)jarg1;
103848
103849   if (!jarg2) {
103850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103851     return;
103852   }
103853
103854   std::string jarg2str = std::string(jarg2);
103855   arg2 = &jarg2str;
103856   {
103857     try {
103858       (arg1)->LoadUrl((std::string const &)*arg2);
103859     } catch (std::out_of_range& e) {
103860       {
103861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103862       };
103863     } catch (std::exception& e) {
103864       {
103865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103866       };
103867     } catch (Dali::DaliException e) {
103868       {
103869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103870       };
103871     } catch (...) {
103872       {
103873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103874       };
103875     }
103876   }
103877 }
103878
103879 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WebView_GetUrl(void * jarg1) {
103880   char * jresult ;
103881   std::string result;
103882
103883   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103884
103885   arg1 = (Dali::Toolkit::WebView *)jarg1;
103886   {
103887     try {
103888       result = arg1->GetUrl();
103889     } catch (std::out_of_range& e) {
103890       {
103891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103892       };
103893     } catch (std::exception& e) {
103894       {
103895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103896       };
103897     } catch (Dali::DaliException e) {
103898       {
103899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103900       };
103901     } catch (...) {
103902       {
103903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103904       };
103905     }
103906   }
103907
103908   jresult = SWIG_csharp_string_callback((&result)->c_str());
103909   return jresult;
103910 }
103911
103912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103913   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103914   std::string *arg2;
103915
103916   arg1 = (Dali::Toolkit::WebView *)jarg1;
103917   if (!jarg2) {
103918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103919     return;
103920   }
103921   std::string jarg2str = std::string(jarg2);
103922   arg2 = &jarg2str;
103923   {
103924     try {
103925       (arg1)->LoadHTMLString((std::string const &)*arg2);
103926     } catch (std::out_of_range& e) {
103927       {
103928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103929       };
103930     } catch (std::exception& e) {
103931       {
103932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103933       };
103934     } catch (Dali::DaliException e) {
103935       {
103936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103937       };
103938     } catch (...) {
103939       {
103940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103941       };
103942     }
103943   }
103944 }
103945
103946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103947   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103948
103949   arg1 = (Dali::Toolkit::WebView *)jarg1;
103950   {
103951     try {
103952       (arg1)->Reload();
103953     } catch (std::out_of_range& e) {
103954       {
103955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103956       };
103957     } catch (std::exception& e) {
103958       {
103959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103960       };
103961     } catch (Dali::DaliException e) {
103962       {
103963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103964       };
103965     } catch (...) {
103966       {
103967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103968       };
103969     }
103970   }
103971 }
103972
103973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103974   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103975
103976   arg1 = (Dali::Toolkit::WebView *)jarg1;
103977   {
103978     try {
103979       (arg1)->StopLoading();
103980     } catch (std::out_of_range& e) {
103981       {
103982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103983       };
103984     } catch (std::exception& e) {
103985       {
103986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103987       };
103988     } catch (Dali::DaliException e) {
103989       {
103990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103991       };
103992     } catch (...) {
103993       {
103994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103995       };
103996     }
103997   }
103998 }
103999
104000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
104001   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104002
104003   arg1 = (Dali::Toolkit::WebView *)jarg1;
104004   {
104005     try {
104006       (arg1)->GoBack();
104007     } catch (std::out_of_range& e) {
104008       {
104009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104010       };
104011     } catch (std::exception& e) {
104012       {
104013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104014       };
104015     } catch (Dali::DaliException e) {
104016       {
104017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104018       };
104019     } catch (...) {
104020       {
104021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104022       };
104023     }
104024   }
104025 }
104026
104027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
104028   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104029
104030   arg1 = (Dali::Toolkit::WebView *)jarg1;
104031   {
104032     try {
104033       (arg1)->GoForward();
104034     } catch (std::out_of_range& e) {
104035       {
104036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104037       };
104038     } catch (std::exception& e) {
104039       {
104040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104041       };
104042     } catch (Dali::DaliException e) {
104043       {
104044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104045       };
104046     } catch (...) {
104047       {
104048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104049       };
104050     }
104051   }
104052 }
104053
104054 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
104055   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104056   bool ret;
104057
104058   arg1 = (Dali::Toolkit::WebView *)jarg1;
104059   {
104060     try {
104061       ret = (arg1)->CanGoBack();
104062     } catch (std::out_of_range& e) {
104063       {
104064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
104065       };
104066     } catch (std::exception& e) {
104067       {
104068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
104069       };
104070     } catch (Dali::DaliException e) {
104071       {
104072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
104073       };
104074     } catch (...) {
104075       {
104076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
104077       };
104078     }
104079   }
104080   return ret;
104081 }
104082
104083 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
104084   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104085   bool ret;
104086
104087   arg1 = (Dali::Toolkit::WebView *)jarg1;
104088   {
104089     try {
104090       ret = (arg1)->CanGoForward();
104091     } catch (std::out_of_range& e) {
104092       {
104093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
104094       };
104095     } catch (std::exception& e) {
104096       {
104097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
104098       };
104099     } catch (Dali::DaliException e) {
104100       {
104101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
104102       };
104103     } catch (...) {
104104       {
104105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
104106       };
104107     }
104108   }
104109   return ret;
104110 }
104111
104112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2) {
104113   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104114   std::string *arg2;
104115
104116   arg1 = (Dali::Toolkit::WebView *)jarg1;
104117   if (!jarg2) {
104118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
104119     return;
104120   }
104121   std::string jarg2_str = std::string(jarg2);
104122   arg2 = &jarg2_str;
104123   {
104124     try {
104125       (arg1)->EvaluateJavaScript((std::string const &)*arg2);
104126     } catch (std::out_of_range& e) {
104127       {
104128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104129       };
104130     } catch (std::exception& e) {
104131       {
104132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104133       };
104134     } catch (Dali::DaliException e) {
104135       {
104136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104137       };
104138     } catch (...) {
104139       {
104140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104141       };
104142     }
104143   }
104144 }
104145
104146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
104147   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104148
104149   arg1 = (Dali::Toolkit::WebView *)jarg1;
104150   {
104151     try {
104152       (arg1)->ClearHistory();
104153     } catch (std::out_of_range& e) {
104154       {
104155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104156       };
104157     } catch (std::exception& e) {
104158       {
104159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104160       };
104161     } catch (Dali::DaliException e) {
104162       {
104163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104164       };
104165     } catch (...) {
104166       {
104167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104168       };
104169     }
104170   }
104171 }
104172
104173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
104174   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104175
104176   arg1 = (Dali::Toolkit::WebView *)jarg1;
104177   {
104178     try {
104179       (arg1)->ClearCache();
104180     } catch (std::out_of_range& e) {
104181       {
104182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104183       };
104184     } catch (std::exception& e) {
104185       {
104186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104187       };
104188     } catch (Dali::DaliException e) {
104189       {
104190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104191       };
104192     } catch (...) {
104193       {
104194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104195       };
104196     }
104197   }
104198 }
104199
104200 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
104201     return (Dali::Toolkit::Control *)jarg1;
104202 }
104203
104204
104205 // Proxy class of WebViewSignal.
104206 // WebViewSignal has an argument of std::string type which is not supported at C# side.
104207 // The purpose of this class is to convert signal argument of string type safely.
104208 class WebViewSignalProxy : public ConnectionTracker
104209 {
104210 public:
104211   typedef Dali::Signal< void(Dali::Toolkit::WebView, const std::string&) > OriginalSignalType;
104212   typedef Dali::Signal< void(Dali::Toolkit::WebView, char*) > ProxySignalType;
104213   typedef void (*CallbackType)(Dali::Toolkit::WebView, char *);
104214
104215   WebViewSignalProxy(OriginalSignalType* signal)
104216     : mSignalPtr(signal)
104217   {
104218   }
104219
104220   void Connect(CallbackType csharpCallback)
104221   {
104222     if (mSignalPtr->Empty())
104223     {
104224       mSignalPtr->Connect(this, &WebViewSignalProxy::OnEmit);
104225     }
104226     mProxySignal.Connect(csharpCallback);
104227   }
104228
104229   void Disconnect(CallbackType csharpCallback)
104230   {
104231     mProxySignal.Disconnect(csharpCallback);
104232     if (mProxySignal.Empty())
104233     {
104234       mSignalPtr->Disconnect(this, &WebViewSignalProxy::OnEmit);
104235     }
104236   }
104237
104238   bool Empty()
104239   {
104240     return mProxySignal.Empty();
104241   }
104242
104243   std::size_t GetConnectionCount()
104244   {
104245     return mProxySignal.GetConnectionCount();
104246   }
104247
104248   void Emit(Dali::Toolkit::WebView& webview, char* url)
104249   {
104250     if (!mProxySignal.Empty())
104251     {
104252       mProxySignal.Emit(webview, url);
104253     }
104254   }
104255
104256   void OnEmit(Dali::Toolkit::WebView webview, const std::string& url)
104257   {
104258     // Safe string conversion
104259     mProxySignal.Emit(webview, SWIG_csharp_string_callback(url.c_str()));
104260   }
104261
104262 private:
104263   OriginalSignalType* mSignalPtr;
104264   ProxySignalType mProxySignal;
104265 };
104266
104267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadStarted(void * jarg1) {
104268   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
104269   WebViewSignalProxy* result = NULL;
104270   {
104271     try {
104272       result = new WebViewSignalProxy(&webview->PageLoadStartedSignal());
104273     } catch (std::out_of_range& e) {
104274       {
104275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104276       };
104277     } catch (std::exception& e) {
104278       {
104279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104280       };
104281     } catch (Dali::DaliException e) {
104282       {
104283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104284       };
104285     } catch (...) {
104286       {
104287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104288       };
104289     }
104290   }
104291   return (void*) result;
104292 }
104293
104294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadFinished(void * jarg1) {
104295   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
104296   WebViewSignalProxy* result = NULL;
104297   {
104298     try {
104299       result = new WebViewSignalProxy(&webview->PageLoadFinishedSignal());
104300     } catch (std::out_of_range& e) {
104301       {
104302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104303       };
104304     } catch (std::exception& e) {
104305       {
104306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104307       };
104308     } catch (Dali::DaliException e) {
104309       {
104310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104311       };
104312     } catch (...) {
104313       {
104314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104315       };
104316     }
104317   }
104318   return (void*) result;
104319 }
104320
104321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewSignalProxy(void * jarg1)
104322 {
104323   WebViewSignalProxy* object = (WebViewSignalProxy*) jarg1;
104324   {
104325     try {
104326       delete object;
104327     } catch (std::out_of_range& e) {
104328       {
104329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104330       };
104331     } catch (std::exception& e) {
104332       {
104333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104334       };
104335     } catch (Dali::DaliException e) {
104336       {
104337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104338       };
104339     } catch (...) {
104340       {
104341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104342       };
104343     }
104344   }
104345 }
104346
104347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Empty(void * jarg1)
104348 {
104349   bool result;
104350   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104351   {
104352     try {
104353       result = (bool)proxy->Empty();
104354     } catch (std::out_of_range& e) {
104355       {
104356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104357       };
104358     } catch (std::exception& e) {
104359       {
104360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104361       };
104362     } catch (Dali::DaliException e) {
104363       {
104364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104365       };
104366     } catch (...) {
104367       {
104368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104369       };
104370     }
104371   }
104372   return (unsigned int) result;
104373 }
104374
104375
104376 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_GetConnectionCount(void * jarg1)
104377 {
104378   std::size_t result;
104379   WebViewSignalProxy* arg1 = (WebViewSignalProxy*) jarg1;
104380   {
104381     try {
104382       result = arg1->GetConnectionCount();
104383     } catch (std::out_of_range& e) {
104384       {
104385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104386       };
104387     } catch (std::exception& e) {
104388       {
104389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104390       };
104391     } catch (Dali::DaliException e) {
104392       {
104393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104394       };
104395     } catch (...) {
104396       {
104397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104398       };
104399     }
104400   }
104401   return (unsigned long) result;
104402 }
104403
104404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Connect(void * jarg1, void * jarg2)
104405 {
104406   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104407   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
104408   {
104409     try {
104410       proxy->Connect(callback);
104411     } catch (std::out_of_range& e) {
104412       {
104413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104414       };
104415     } catch (std::exception& e) {
104416       {
104417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104418       };
104419     } catch (Dali::DaliException e) {
104420       {
104421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104422       };
104423     } catch (...) {
104424       {
104425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104426       };
104427     }
104428   }
104429 }
104430
104431
104432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Disconnect(void * jarg1, void * jarg2) {
104433   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104434   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
104435   {
104436     try {
104437       proxy->Disconnect(callback);
104438     } catch (std::out_of_range& e) {
104439       {
104440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104441       };
104442     } catch (std::exception& e) {
104443       {
104444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104445       };
104446     } catch (Dali::DaliException e) {
104447       {
104448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104449       };
104450     } catch (...) {
104451       {
104452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104453       };
104454     }
104455   }
104456 }
104457
104458
104459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Emit(void * jarg1, void * jarg2, char * jarg3) {
104460   if (!jarg2) {
104461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView & type is null", 0);
104462     return ;
104463   }
104464   if (!jarg3) {
104465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0);
104466     return ;
104467   }
104468
104469   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104470   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*) jarg2;
104471   {
104472     try {
104473       proxy->Emit(*webview, jarg3);
104474     } catch (std::out_of_range& e) {
104475       {
104476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104477       };
104478     } catch (std::exception& e) {
104479       {
104480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104481       };
104482     } catch (Dali::DaliException e) {
104483       {
104484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104485       };
104486     } catch (...) {
104487       {
104488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104489       };
104490     }
104491   }
104492 }
104493
104494 #ifdef __cplusplus
104495 }
104496 #endif
104497